简单说一下这个项目

项目地址：microsoft/autogen

看到官方的概述的时候有点惊讶到了，这更像是LLM分布式集群的感觉，一个Agent下发任务给到多个Agent，但是同以往不一样的是，每一层级的Agent都是能够双相通信，这样的话我前面说到的“层级”其实就是不准确了，它更像是平级的团队。

项目README的概述：

这个项目是FLAML的一个分支。

autogen已经从FLAML毕业，成为一个新的项目。

AutoGen是一个框架，它可以使用多个可以相互对话来解决任务的智能体来开发LLM应用。AutoGen智能体是可定制的，可对话的，并且无缝地允许人类参与。它们可以在使用LLM、人类输入和工具的各种模式下运行。

AutoGen使得用最小的努力构建下一代LLM应用成为可能。它简化了复杂LLM工作流的编排、自动化和优化。它最大化了LLM模型的性能，并克服了它们的弱点。

它支持复杂工作流的多种对话模式。通过可定制和可对话的智能体，开发者可以使用AutoGen构建多种对话模式，涉及对话自主性、智能体数量和> 智能体对话拓扑。

它提供了一系列具有不同复杂度的工作系统。这些系统涵盖了各个领域和复杂度的广泛应用。这展示了AutoGen如何轻松地支持多种对话模式。

AutoGen提供了一个替代openai.Completion或openai.ChatCompletion的增强推理API。它允许轻松地进行性能调优、实用工具（如API统一和> 缓存）和高级使用模式（如错误处理、多配置推理、上下文编程等）。

AutoGen是由微软、宾夕法尼亚州立大学和华盛顿大学的合作研究项目提供支持的。

然后查阅官方给到的文档去使用本地模型完成部署 文档地址

本地部署

原文：

Clone FastChat​

FastChat provides OpenAI-compatible APIs for its supported models, so you can use FastChat as a local drop-in replacement for OpenAI APIs. However, its code needs minor modification in order to function properly.

1 2	git clone https://github.com/lm-sys/FastChat.git cd FastChat

Download checkpoint​

ChatGLM-6B is an open bilingual language model based on General Language Model (GLM) framework, with 6.2 billion > parameters. ChatGLM2-6B is its second-generation version.

Before downloading from HuggingFace Hub, you need to have Git LFS installed.

1	git clone https://huggingface.co/THUDM/chatglm2-6b

Initiate server

First, launch the controller

1	python -m fastchat.serve.controller

Then, launch the model worker(s)

1	python -m fastchat.serve.model_worker --model-path chatglm2-6b

Finally, launch the RESTful API server

1	python -m fastchat.serve.openai_api_server --host localhost --port 8000

Normally this will work. However, if you encounter error like this, commenting out all the lines containing > finish_reason in fastchat/protocol/api_protocal.py and fastchat/protocol/openai_api_protocol.py will fix the > problem. The modified code looks like:

1 2 3 4 5 6 7 8 9 10 11

class CompletionResponseChoice(BaseModel): index: int text: str logprobs: Optional[int] = None # finish_reason: Optional[Literal["stop", "length"]] class CompletionResponseStreamChoice(BaseModel): index: int text: str logprobs: Optional[float] = None # finish_reason: Optional[Literal["stop", "length"]] = None

Interact with model using oai.Completion

Now the models can be directly accessed through openai-python library as well as autogen.oai.Completion and autogen.oai.ChatCompletion.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

from autogen import oai # create a text completion request response = oai.Completion.create( config_list=[ { "model": "chatglm2-6b", "api_base": "http://localhost:8000/v1", "api_type": "open_ai", "api_key": "NULL", # just a placeholder } ], prompt="Hi", ) print(response) # create a chat completion request response = oai.ChatCompletion.create( config_list=[ { "model": "chatglm2-6b", "api_base": "http://localhost:8000/v1", "api_type": "open_ai", "api_key": "NULL", } ], messages=[{"role": "user", "content": "Hi"}] ) print(response)

If you would like to switch to different models, download their checkpoints and specify model path when launching model worker(s).

interacting with multiple local LLMs​

If you would like to interact with multiple LLMs on your local machine, replace the model_worker step above with a multi model variant:

1 2 3 4 5

python -m fastchat.serve.multi_model_worker \ --model-path lmsys/vicuna-7b-v1.3 \ --model-names vicuna-7b-v1.3 \ --model-path chatglm2-6b \ --model-names chatglm2-6b

The inference code would be:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

from autogen import oai # create a chat completion request response = oai.ChatCompletion.create( config_list=[ { "model": "chatglm2-6b", "api_base": "http://localhost:8000/v1", "api_type": "open_ai", "api_key": "NULL", }, { "model": "vicuna-7b-v1.3", "api_base": "http://localhost:8000/v1", "api_type": "open_ai", "api_key": "NULL", } ], messages=[{"role": "user", "content": "Hi"}] ) print(response)

总结一下其实就是将chatglm2开放为一个接口提供给AutoGen调用，同理将模型封装为API都能提供给AutoGen调用。

实践出真知

安装fastchat

安装serve库

然后启动本地的LLM模型

因为我的模型路径为 /home/kers/lab/transformers/models/THUDM/chatglm2-6b/，所以启动命令如下：

1

python -m fastchat.serve.model_worker --model-path /home/kers/lab/transformers/models/THUDM/chatglm2-6b/

出现问题

报了一个错误：RuntimeError: The NVIDIA driver on your system is too old (found version 11020). Please update your GPU driver by downloading and installing a new version from the URL: http://www.nvidia.com/Download/index.aspx Alternatively, go to: https://pytorch.org to install a PyTorch version that has been compiled with your version of the CUDA driver.
意思就是我的 CUDA 版本太老了，图中我是用 nvidia-smi 输出了相关信息，能看到我的版本是 11.2 那么我们更新驱动。

这个驱动的版本是 12.2 目前的最新版本。

更新完成了，

我在日常冲浪的时候听到了一首歌：

其中有一段歌词，直接把我抓死了 :喷鼻血: :爱心眼:
虽然你们可能有人不明白为什么，哪里，可能甚至觉得一般，但是我就是喜欢哈哈哈哈哈，然后，我“翻唱”了

这首歌很简单，走向也非常简单，但是我就是感觉很好听，化繁为简的魅力。

暂时还没有纯乐版本的，我就小小记录一下啦~

我甚至连乐器名称都懒得改，中间那个转调我写的真棒！！！！我真厉害！

就这样，respect！

这东西有些迅猛啊，才是2022年底的略有名气，现在才2023刚开春，GPT-4了？
也体验过，程序员确实把自己淘汰了。

你可能想问 “不对啊，淘汰的也只是那些面向CV的程序员吧” 但其实不是的。

GPT这个模型的出现就标注着大数据时代的高光点终会落在上面了。较为通俗的话语是“通过前面的内容预测后面会是什么”

NLP语言大模型

仅3周测试

这个信息对从事开发的人来说无疑是惊悚的。

GPT-2是一种基于深度学习技术的自然语言处理模型，它可以生成高质量、流畅的文本内容。这种模型可以应用于多个领域，例如机器翻译、智能客服、舆情分析等。而在过去，训练这样的模型需要大量的数据和计算资源，并且需要经过漫长的调试和优化过程。

在GPT-2发布后不久，就有人担心其可能被滥用或误用，例如用于制造虚假新闻、欺诈行为等。因此，OpenAI公司决定限制GPT-2的公开访问，并只向特定用户提供API接口。

但是也仅仅测试了3周就完成了全部单元的测试。

是钞能力吗？

GPT-4

他们是这么说的：

We’ve created GPT-4, the latest milestone in OpenAI’s effort in scaling up deep learning. GPT-4 is a large multimodal model (accepting image and text inputs, emitting text outputs) that, while less capable than humans in many real-world scenarios, exhibits human-level performance on various professional and academic benchmarks.

在信息输入后模型处理的过程中进行了输出类型的预测
处理广泛的编程任务，从编程挑战到现实世界的应用，从低级汇编到高级框架，从简单的数据结构到复杂的程序，如游戏。
对代码执行进行推理，模拟指令的效果，并用自然语言解释结果。
执行伪代码，这需要解释在任何编程语言中都无效的非正式和模糊的表达。

潘多拉魔盒真的打开了吗？

中国有没有

假设国内有了，叫 Chatna。
第二天：社评，语言模型不能成为脱缰野马。
第三天：老胡认为，AI 生成的内容错误百出，将让互联网成为泥潭。
第四天：新闻，涉及多起侵权案件。
第五天：停业整顿。
第六天：根据相关法律法规和政策。。。未予显示。。。
实名认证。
审查交流内容。封号。
增加隐写水印。
This is Chatna.

博主说一句：中国的NLP大模型至少落后世界2年了

在未来

如果不会使用人工智能那么就等于不会使用百度。
如果你真的想要会用ChatGPT或者其他的GPT大模型，那么你需要知道GPT是什么，它是如何工作去读懂你的意思的，你可能觉得，这不就是一个语言模型，他有一个神经网络可以读懂你的意思那是不够的。

浅谈GPT

GPT是OpenAI的ChatGPT带火的，但是你要知道GPT已经出现了接近6年。
它通常指的是”Generative Pre-trained Transformer”（生成式预训练变换器）模型，是一种基于深度学习的自然语言处理（NLP）模型。
那么现在又有一个词“Transformer”

基本概念

Transformer是一种广泛用于序列到序列任务的架构，由”Attention is All You Need”论文提出。该架构通过自注意力机制（self-attention）来捕捉输入序列中的上下文信息，实现了对长距离依赖关系的建模。

打住！

要学会使用GPT这时候已经足够了，既然它是”Generative Pre-trained Transformer”（生成式预训练变换器）模型，那么从某种意义上来说，它不太熟练更改已有的内容（如果知道BERT的掩码训练，这里应该秒懂）

既然了解GPT和ChatGPT的基本概念是学习使用它们的第一步。
首先需要明确，GPT模型都基于机器学习，那么是不是还需要进行学习机器学习再而学习transformers或者tensorflow？

举个栗子🌰

单样本微调给ChatGLM2注入知识

summary:

(1) 只需要1条样本，很少的训练时间，就可以通过微调给LLM注入知识。

(2) LLM是一种类似Key-Value形式的知识数据库，支持增删改查。通过微调可以增删修改知识，通过条件生成可以查询提取知识。

(3) LoRA微调是一种高效的融入学习算法。类似人类把新知识融入现有知识体系的学习过程。学习时无需新知识特别多的样本，学习后原有的庞大知识和能力可以基本不受影响。

微调前：

微调后：

1
2
3
4
5
6

# 导入常用模块
import numpy as np
import pandas as pd 
import torch
from torch import nn 
from torch.utils.data import Dataset, DataLoader 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 配置参数
from argparse import Namespace
cfg = Namespace()

#dataset
cfg.prompt_column = 'prompt'
cfg.response_column = 'response'
cfg.history_column = None
cfg.source_prefix = '' #添加到每个prompt开头的前缀引导语

cfg.max_source_length = 128 
cfg.max_target_length = 128

#model
cfg.model_name_or_path = 'chatglm2-6b'  #远程'THUDM/chatglm-6b' 
cfg.quantization_bit = None #仅仅预测时可以选 4 or 8 


#train
cfg.epochs = 100 
cfg.lr = 5e-3
cfg.batch_size = 1
cfg.gradient_accumulation_steps = 16 #梯度累积

预训练模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import transformers
from transformers import  AutoModel,AutoTokenizer,AutoConfig,DataCollatorForSeq2Seq


config = AutoConfig.from_pretrained(cfg.model_name_or_path, trust_remote_code=True)

tokenizer = AutoTokenizer.from_pretrained(
    cfg.model_name_or_path, trust_remote_code=True)

model = AutoModel.from_pretrained(
    cfg.model_name_or_path,
    config=config,
    trust_remote_code=True
  ).half() 

#先量化瘦身
if cfg.quantization_bit is not None:
    print(f"Quantized to {cfg.quantization_bit} bit")
    model = model.quantize(cfg.quantization_bit)
    
#再移动到GPU上
model = model.cuda()

1
2
3

# 通过注册jupyter魔法命令可以很方便地在jupyter中测试ChatGLM 
from torchkeras.chat import ChatGLM 
chatglm = ChatGLM(model,tokenizer)

你知道梦中情炉吗？
“梦中情炉”在我所掌握的信息中并没有被提及或描述过。请问您需要了解什么关于“梦中情炉”的信息吗？

介绍一下梦中情炉
很抱歉，在我所掌握的信息中并没有关于“梦中情炉”的相关描述。如果您需要了解关于炉子的信息，我可以为您提供帮助。请告诉我您想了解关于炉子什么方面的信息，我会尽力为您提供帮助。

准备数据

构造数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#定义一条知识样本~

keyword = '梦中情炉'

description = '''梦中情炉一般指的是炼丹工具torchkeras。
这是一个通用的pytorch模型训练模版工具。
torchkeras是一个三好炼丹炉：好看，好用，好改。
她有torch的灵动，也有keras的优雅，并且她的美丽，无与伦比。
所以她的作者一个有毅力的吃货给她取了一个别名叫做梦中情炉。'''

#对prompt使用一些简单的数据增强的方法，以便更好地收敛。
def get_prompt_list(keyword):
    return [f'{keyword}', 
            f'你知道{keyword}吗?',
            f'{keyword}是什么？',
            f'介绍一下{keyword}',
            f'你听过{keyword}吗?',
            f'啥是{keyword}？',
            f'{keyword}是何物？',
            f'何为{keyword}？',
           ]

data =[{'prompt':x,'response':description} for x in get_prompt_list(keyword) ]
dfdata = pd.DataFrame(data)
display(dfdata) 

1
2
3

import datasets 
#训练集和验证集一样
ds_train_raw = ds_val_raw = datasets.Dataset.from_pandas(dfdata)

数据转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#这是支持 history列处理，并且按照batch预处理数据的方法。

def preprocess(examples):
    max_seq_length = cfg.max_source_length + cfg.max_target_length
    model_inputs = {
        "input_ids": [],
        "labels": [],
    }
    for i in range(len(examples[cfg.prompt_column])):
        if examples[cfg.prompt_column][i] and examples[cfg.response_column][i]:
            query, answer = examples[cfg.prompt_column][i], examples[cfg.response_column][i]

            history = examples[cfg.history_column][i] if cfg.history_column is not None else None
            prompt = tokenizer.build_prompt(query, history)

            prompt = cfg.source_prefix + prompt
            a_ids = tokenizer.encode(text=prompt, add_special_tokens=True, truncation=True,
                                     max_length=cfg.max_source_length)
            b_ids = tokenizer.encode(text=answer, add_special_tokens=False, truncation=True,
                                     max_length=cfg.max_target_length)

            context_length = len(a_ids)
            input_ids = a_ids + b_ids + [tokenizer.eos_token_id]
            labels = [tokenizer.pad_token_id] * context_length + b_ids + [tokenizer.eos_token_id]

            pad_len = max_seq_length - len(input_ids)
            input_ids = input_ids + [tokenizer.pad_token_id] * pad_len
            labels = labels + [tokenizer.pad_token_id] * pad_len
            labels = [(l if l != tokenizer.pad_token_id else -100) for l in labels]
            model_inputs["input_ids"].append(input_ids)
            model_inputs["labels"].append(labels)
    return model_inputs

1
2
3
4
5
6
7
8
9
10
11
12
13

ds_train = ds_train_raw.map(
    preprocess,
    batched=True,
    num_proc=4,
    remove_columns=ds_train_raw.column_names
)

ds_val = ds_val_raw.map(
    preprocess,
    batched=True,
    num_proc=4,
    remove_columns=ds_val_raw.column_names
)

构建管道

1
2
3
4
5
6
7
8
9
10
11
12
13
14

data_collator = DataCollatorForSeq2Seq(
    tokenizer,
    model=None,
    label_pad_token_id=-100,
    pad_to_multiple_of=None,
    padding=False
)

dl_train = DataLoader(ds_train,batch_size = cfg.batch_size,
                      num_workers = 2, shuffle = True, collate_fn = data_collator 
                     )
dl_val = DataLoader(ds_val,batch_size = cfg.batch_size,
                      num_workers = 2, shuffle = False, collate_fn = data_collator 
                     )

1
2

for batch in dl_train:
    break

1

print(len(dl_train))

定义模型

下面我们使用AdaLoRA方法来微调ChatGLM2，以便给模型注入和梦中情炉 torchkeras相关的知识。

AdaLoRA是LoRA方法的一种升级版本，使用方法与LoRA基本一样。

主要差异在于，在LoRA中不同训练参数矩阵的秩是一样的被固定的。

但AdaLoRA中不同训练参数矩阵的秩是会在一定范围内自适应调整的，那些更重要的训练参数矩阵会分配到更高的秩。

通常认为，AdaLoRA的效果会好于LoRA。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from peft import get_peft_model, AdaLoraConfig, TaskType

#训练时节约GPU占用
model.config.use_cache=False
model.supports_gradient_checkpointing = True  #
model.gradient_checkpointing_enable()
model.enable_input_require_grads()

peft_config = AdaLoraConfig(
    task_type=TaskType.CAUSAL_LM, inference_mode=False,
    r=8,
    lora_alpha=32, lora_dropout=0.1,
    target_modules=["query", "value"]
)

peft_model = get_peft_model(model, peft_config)

peft_model.is_parallelizable = True
peft_model.model_parallel = True
peft_model.print_trainable_parameters()

训练模型

我们使用我们的梦中情炉torchkeras来实现最优雅的训练循环~

注意这里，为了更加高效地保存和加载参数，我们覆盖了KerasModel中的load_ckpt和save_ckpt方法，

仅仅保存和加载可训练lora权重，这样可以避免加载和保存全部模型权重造成的存储问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

from torchkeras import KerasModel 
from accelerate import Accelerator 

class StepRunner:
    def __init__(self, net, loss_fn, accelerator=None, stage = "train", metrics_dict = None, 
                 optimizer = None, lr_scheduler = None
                 ):
        self.net,self.loss_fn,self.metrics_dict,self.stage = net,loss_fn,metrics_dict,stage
        self.optimizer,self.lr_scheduler = optimizer,lr_scheduler
        self.accelerator = accelerator if accelerator is not None else Accelerator() 
        if self.stage=='train':
            self.net.train() 
        else:
            self.net.eval()
    
    def __call__(self, batch):
        
        #loss
        with self.accelerator.autocast():
            loss = self.net(input_ids=batch["input_ids"],labels=batch["labels"]).loss

        #backward()
        if self.optimizer is not None and self.stage=="train":
            self.accelerator.backward(loss)
            if self.accelerator.sync_gradients:
                self.accelerator.clip_grad_norm_(self.net.parameters(), 1.0)
            self.optimizer.step()
            if self.lr_scheduler is not None:
                self.lr_scheduler.step()
            self.optimizer.zero_grad()
            
        all_loss = self.accelerator.gather(loss).sum()
        
        #losses (or plain metrics that can be averaged)
        step_losses = {self.stage+"_loss":all_loss.item()}
        
        #metrics (stateful metrics)
        step_metrics = {}
        
        if self.stage=="train":
            if self.optimizer is not None:
                step_metrics['lr'] = self.optimizer.state_dict()['param_groups'][0]['lr']
            else:
                step_metrics['lr'] = 0.0
        return step_losses,step_metrics
    
KerasModel.StepRunner = StepRunner 


#仅仅保存lora相关的可训练参数
def save_ckpt(self, ckpt_path='checkpoint', accelerator = None):
    unwrap_net = accelerator.unwrap_model(self.net)
    unwrap_net.save_pretrained(ckpt_path)
    
def load_ckpt(self, ckpt_path='checkpoint'):
    self.net = self.net.from_pretrained(self.net.base_model.model,ckpt_path)
    self.from_scratch = False
    
KerasModel.save_ckpt = save_ckpt 
KerasModel.load_ckpt = load_ckpt 

1
2
3
4

optimizer = torch.optim.AdamW(peft_model.parameters(),lr=cfg.lr) 
keras_model = KerasModel(peft_model,loss_fn = None,
        optimizer=optimizer) 
ckpt_path = 'single_chatglm2'

1
2
3
4
5
6
7
8
9
10

keras_model.fit(train_data = dl_train,
                val_data = dl_val,
                epochs=100,
                patience=20,
                monitor='val_loss',
                mode='min',
                ckpt_path = ckpt_path,
                mixed_precision='fp16',
                gradient_accumulation_steps = cfg.gradient_accumulation_steps
               )

验证模型

1
2
3
4
5
6
7

from peft import PeftModel 
ckpt_path = 'single_chatglm2'
model_old = AutoModel.from_pretrained("chatglm2-6b",
                                  load_in_8bit=False, 
                                  trust_remote_code=True)
peft_loaded = PeftModel.from_pretrained(model_old,ckpt_path).cuda()
model_new = peft_loaded.merge_and_unload() #合并lora权重

1

chatglm = ChatGLM(model_new,tokenizer,max_chat_rounds=20) #支持多轮对话，可以从之前对话上下文提取知识。

使用模型

我们尝试触碰一下模型学到的知识的边界在哪里，并看一下模型的其它能力是否受到影响。

为了直接测试模型提取知识的能力，我们关闭掉多轮对话功能，不让模型从上下文提取知识。

😂😂

从这个测试中，我们可以看到模型能够注入和提取知识，并且注入知识后基本不会影响到旧知识。

但是模型能够直接提取出知识的场景，必须是 问题 和我们训练时语义非常相似的情况。

‘what is 梦中情炉’ 和 ‘这是个啥子意思哟:梦中情炉?’ 都是这样的例子。

在以’以梦中情炉为主题，写一首优美的现代诗歌，要有激情，有感染力~’ 和 ‘torchkeras是个啥子哦?’ 的例子中，

虽然我们的知识库中有梦中情炉，也就是torchkeras相关的知识，但是这两个问题和我们训练时候的语义相差很大，所以无法直接提取出来并应用相关的知识。

从这个意义上说，LLM模型非常像一个key-value类型的知识数据库，这里的key是某种语义，而不是某个特定的词。

通过微调，我们可以给这个知识数据库注入，删除，和修改知识（设计目标输出成我们需要的形式即可）。

通过输入和训练时语义相近的提示词，我们可以从这个知识数据库中查询提取知识。

只有查询提取知识到对话上下文之后，LLM才能够灵活地使用知识。

保存模型

可以将模型和tokenizer，以及相关py文件都保存到一个新的路径，便于直接加载。

1
2

save_path = "chatglm2-6b-梦中情炉"
model_new.save_pretrained(save_path, max_shard_size='2GB')

1
2
3
4
5
6
7

tokenizer.save_pretrained(save_path) 
"""
('chatglm2-6b-梦中情炉/tokenizer_config.json',
 'chatglm2-6b-梦中情炉/special_tokens_map.json',
 'chatglm2-6b-梦中情炉/tokenizer.model',
 'chatglm2-6b-梦中情炉/added_tokens.json')
"""

PS: 还需要将相关的py文件也复制过去。

总结延申

演示了使用AdaLoRA算法，使用1条样本对ChatGLM2实施微调。几分钟就成功注入了”梦中情炉”有关的知识。

总结:

(1) 只需要1条样本，很少的训练时间，就可以通过微调给LLM注入知识。

(2) LLM是一种知识数据库，支持增删改查。通过微调可以增删修改知识，通过条件生成可以查询提取知识。

(3) LoRA微调是一种高效的融入学习算法。类似人类把新知识融入现有知识体系的学习过程。学习时无需新知识特别多的样本，学习后原有的庞大知识和能力可以基本不受影响。

问题:

(1) 如果我们有很多条例如几千几万条知识，如何才能比较高效地给LLM注入并确保每条都注入成功呢?

第一种想法是常规的微调方法，我们把这些知识混合成一个数据集用LoRA进行微调。

第二种方法是让LLM用单样本微调的方法一条知识一条知识地学习，确保学习成功了一条知识后合并LoRA权重再去学习下一条。

出于人类学习的经验，我可能觉得第二种会更加高效且可靠。或者也可能某种中间方案会更好，例如几条或者几十条知识作为一个学习批次，学习完了后再去学习下一个。究竟哪种更好，需要我们去做实验尝试。

(2) 如果说ChatGLM2-6b可以作为一种Key-Value结构的知识数据库，我们知道这个模型的参数权重规模大概是60亿，也就是6个G，那么这个数据库能够储存超过6个G比如10个G的知识信息吗？能够存储无限的知识信息吗也就是有存储上限吗？如果有上限的话，给它喂入超过其存储能力上限的知识，会发生什么呢？

这个问题触碰到我认知的边界了，我尝试用直觉答一下。LLM应该能够存储远超过其参数权重规模的知识，因为它做的是一种压缩存储，并且压缩率很高。

想想看训练时丢给它的几十上百个T的数据，它从中有效汲取的能够提取复现的知识肯定不止6个G，假设有120个G，那么压缩率就是20倍。

如果把LLM作为一个知识数据库，那它肯定是有存储上限的。如果给他喂入超过其存储能力的数据会发生什么？我想应该是会发生一种类似KV表中的哈希冲突这样的问题。也就是一些旧知识会被遗忘。

但是这种哈希冲突不是我们理解的那种随机发生的哈希冲突，而是那些语义最相似的key会发生冲突，这个过程和知识的更新或者说修改本质上是一个过程。从应用角度来看，这种冲突应该极难发生，并且相比随机的哈希冲突来看还是很良性的。

(3) 为什么通过LoRA微调将新知识融入现有知识体系过程的中，既不需要新知识特别多的样本，同时学习后原有的庞大知识和能力可以不受影响呢？这么优良的特性是怎么发生的？

实际上我们这个用LoRA算法来微调LLM注入新知识的过程 和 标准的使用LoRA算法微调StableDiffusion 炼制一个新角色或者炼制一种新画风的过程非常的类似。

无论从原理还是结果上，都是只需要很少的新知识的样本，同时学习后模型原有的庞大知识和能力基本不受影响。

这个事情的发生确实非常的神奇，非常的美妙，使得我们不得不思考一下背后的原因。

我猜想这个美妙特性的发生是三个要素协同作用的结果。

第一个要素是输入的区分性。

在我们的例子中，我们的新知识的输入通过一个关键词’梦中情炉’来和已有知识体系进行区分。

在StableDiffusion微调炼制新角色也是如此，你需要为你的新角色创建一个独特的名字。

如果在输入上无法明显地区分新旧知识，那么这种和平融入就无法发生，会产生严重的冲突。

第二个要素是预训练模型的抗破坏性。

现在的大部分模型都引入了ResNet结构。拥有ResNet结构的模型本质上属于多个子模型的集成模型。

即使你随机地改变其中一些层的权重，整个模型的输出不会有太大的变化。

同时，训练过程中还使用了dropout，使得模型的抗破坏性进一步增强。

对于旧知识对应的那些输入，即使有些本来相关的权重矩阵被新知识的微调随机地破坏了，输出也几乎不会受到影响。

第三个要素是LoRA的正则性。

LoRA微调的思想是学习两个小的低秩矩阵，用它们的乘积来作为大的参数矩阵需要改变的增量。

这个将增量参数矩阵低秩分解的过程实际上引入了很强的正则性。一方面减少了模型训练的难度，让模型更快地收敛。

同时它可能在一定程度上，也会降低学习新知识的过程中过度调整模型权重，对旧知识产生影响的风险。

但和第一个要素和第二个要素不同，这个特性对降低新旧知识的冲突应该不是最核心的，全参数微调往往也能够和平融合新旧知识。

首尾呼应

没区别

好像就在昨天

一下子好像突然想起什么，一寸一寸叠起来的小房间里我仰着头。我阳了，发烧的挺厉害，我还是坚持坐在桌前，我抬着头，我想着昨天，昨天的昨天，昨天的昨天的，昨天。
嘶，我好像刚开学来着？
不对，一个学期就这么过掉了啊，好快。也不知道是不是因为惶恐疫情提前放假的缘故，我觉得今年格外的短

达芬奇

人们错误地叹息时光的流逝。责备时间过得太快，不认为时间是充裕的，自然赐给我们以好的记忆，使一切事物经历的时问比实际存在的时间还要长久。

回顾2022

我突然好像又不觉得是件坏事了，来让我好好回顾一下我的2022：
起初的，抱有热忱的，反向字体编辑的轮子，立项，到如今也只是停留在了新建文件夹的阶段。
然后我着眼了新的目标———开箱的图床，直到我看到了已经有了的并且非常优秀的PicGo-Core，我望向了其生态，也向往着其生态。
我着手了短视频制作，我记录着我的学习经历，其实这也是我仅仅保留下来的一个习惯了。
赚了！

亲友别离

被带走的还有一张会很大屏障，催促着成长。

有人会说，无能者怀念过去。过去有的盛夏，现在也有，过去有的难道现在没了吗？如果是我，我应该懒得理他，我会认为没什么意义，证明自己有能力又会发生什么？可能，只是会让他换一个地方再这么说一遍。
世界不停的循环着。

不耐烦yes责任

我在学校里，有了一些责任，慎厥初，惟厥终。我不知道成长是一种什么样的体验，可能我正在经历，网络使人相遇是很简单，可是好像让每个人越变越远，我不知道什么时候想明白其实问题不是出在了网络。可能是我老了。
从前，我义愤填膺的在各个角落置评我巴不得告诉全世界我支持的，我理解的。慢慢的，我打开了那个自己的屏蔽按钮。屏蔽外界的同时屏蔽自己了，这样确实会让我舒服不少，越来越觉得我觉得累的是与他人交流。
看到了好多，心里面总是会有一个念头：这是我小时候最渴望拥有的，可是现在我长大了。
我有很多朋友，我希望永远与他们没有利益冲突，甚至没有利益交流，我渴望他们永远是我纯粹的朋友。

挚是执与手

我也遇到了一个志同道合的朋友。
他走过的路我正在走，不吝啬的抛出一个个答案。

引人深思的，
正确的，
难以理解的，
相悖的，

我都没有反驳，我很享受观点的碰撞。

致马上到来的夏天

一年一年真的好快。

确实不能只活在过去。

亏了，当时没好好怼他。

***，不甘心

我有时候不太甘心自己活得太和善，尽管我以往都是如此做的，“谢谢” “抱歉” “不好意思” 泛滥了。
就不值钱了，多少人曾经践踏在我和善的性格之上，我改变着。

我见识过那些自我为中心者，我现在往往会忍着厌恶去配合他们演出。

我也见识过真正的智者深藏暗处，片叶不沾身的智慧把他包装的太神圣了，至少在我心中是这样。

船到桥头自然直

名利对我来说有一定的吸引力，我确实做梦都想着功成名就，我也为此忍了挺久的。

我不想做计划，我不希望计划雪崩那样的事情发生在我身上，干脆！走一步看一步，我对他人的安慰其中除了部分概要分析，就是“船到桥头自然直”

忘得掉

从小到大，好像没什么忘不掉了的，我能释怀一切，啊哈哈哈哈哈。

对不起，不该在这方面开玩笑的，宁可信其有……

我是不是也能烧出舍利

什么什么方丈坐化佛前…那种什么的，我觉得我也有部分很难得的心境，我比较冷静，如果事件的结果我能够承担，那么冷静的必然的。如若？

嘶，不好说。算了，烧不出。

做不完的梦

睡不醒，那就一直睡。

新年快乐

兔年了，好快。

俗言有道，自奉必减几分方好，处世能退一步为高。
之前有很多的前后端开发，数据库其实是一个项目运行的必须的一环，也是很重要的一环。
数据库千千万，合适的到底有哪些？

数据库有哪些

跳过废话

• 关系型数据库
  • Oracle
  • MySQL
• 非关系型数据库
  • NoSQL
• 键值存储数据库（key-value）
  • Memcached
  • Redis
  • MemcacheDB
• 列存储（Column-oriented）数据库
  • Cassandra
  • HBase
• 面向文档（Document-Oriented）数据库
  • MongoDB
  • CouchDB
• 图形数据库
  • Neo4J
  • InforGrid

MongoDB！

https://www.mongodb.com/home

几句话。

不管是kv的内存型redies，还是文档型的mongodb，上手都很都很简单，而且，文档型数据库跟json很像啊，那就更容易理解了，再加上性能还凑合，就他了呗，而且还有mongoose这种玩意，写着毫无压力，个把小时就上手了
敲黑板！时间就是金钱啊，先上了再说玩会了这个流程，是什么数据库不重要，都是store，根据配置切不同实现就完事。至于后面要考虑的存和取的性能和场景，不需要一开始就过度考虑。

妄论一下。

1.Node在io并发处理比较擅长，mongodb也是擅长读写的，两者这方面很契合，mongodb在大数据方面也比较擅长。
2.mongodb是文档数据，数据结构是bson，也可以说是json，而众所周知json是来源于JavaScript object，nodejs又是以js为编程语言。

Js为底层语言

很直观的体现了，在进入Mongo时，执行1 + 1会返回2，dddd

看到这里，其实也跃跃欲试了，如何像博主一样花费30分钟就可以玩得转它？

我知道你很急，但是你先别急。

安装流程

很保姆级了，往下看。

下载。

安装。

无需配置环境变量。

能理解到这一步，其实对shell这类，还有系统这类有一定认识了，mongo.exe其实就是一个cmd程序。

我的bin文件夹

打开目录下的终端，这里不管是cmd还是terminal都可以

先别急着一步步操作，看教程是为了学会，请耐心通读本段落

mongod.exe是创建mongodb的进程，也就是打开数据库的程序

我在D:/创建了文件夹Databases/Mongodb

刚创建文件夹肯定不会像我一样有文件。。。

1

mongod.exe --dbpath "D:/Databases/Mongodb/"

执行完后，你会发现你的文件夹里面生成了文件。

然后，
打开数据库。。。

mongosh.exe是一个可以操作mongodb的命令行程序

1

mongosh.exe

到这里，你拥有了一个Mongodb数据库。

使用方法

创建数据库

尝试使用一个自定义的数据库：

1
2
3
4
5

> use test_db
switched to db test_db
> db
test_db
> 

1
2
3
4
5
6

> show dbs
admin    40.00 KiB
config   72.00 KiB
local    72.00 KiB
test_db   8.00 KiB
> 

“为什么我use的test_db不在里面？”

1
2
3
4
5
6
7
8
9
10
11
12

> db.test_db.insert({"name":"测试"})
DeprecationWarning: Collection.insert() is deprecated. Use insertOne, insertMany, or bulkWrite.
{
  acknowledged: true,
  insertedIds: { '0': ObjectId("63917571c6696a553b3fc68c") }
}
> show dbs
admin    40.00 KiB
config   72.00 KiB
local    72.00 KiB
test_db   8.00 KiB
> 

出现了。
在这一步，Mongodb会在你插入数据的时候自动创建数据库。（很方便）

删除数据库

1
2
3

> db.dropDatabase()
{ ok: 1, dropped: 'test_db' }
> 

集合

列出

1

show collections

创建

1

db.createCollection(name, options)

options

删除

1

db.collection.drop()

文档

于集合下的一个子函数，可以理解为集合的下一级，而文档内存储的就是业务逻辑中的主要内容

插入

1
2
3

db.COLLECTION_NAME.insert(document)
或
db.COLLECTION_NAME.save(document)

更新

1
2
3
4
5
6
7
8
9

db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)

DB类封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

import * as mongodb from 'mongodb';
import { DBI } from './interfaces';

export class Db implements DBI {
    public client: mongodb.MongoClient | undefined;
    public db: mongodb.Db | undefined;

    static instance: Db | null;

    static getInstance() {
        if (!Db.instance) throw "No Event!"
        return this.instance;
    }

    constructor(DB_CONN_STRING: string, DB_NAME: string) {
        this.connection(DB_CONN_STRING, DB_NAME);
    }

    /**
     * 插入数据
     * @param collectionName 集合名称
     * @param doc 内容
     * @returns 
     */
    public insert<T = mongodb.Document>(collectionName: string, doc: mongodb.OptionalId<T>): Promise<mongodb.InsertOneResult<mongodb.Document>> {
        return new Promise<mongodb.InsertOneResult<mongodb.Document>>(async (resolve, reject) => {
            try {
                this.db?.collection(collectionName).insertOne(doc).then(resolve).catch(err => {
                    throw err;
                });
            } catch (err) {
                reject(false);
            }
        });
    }

    /**
     * 插入多数据
     * @param collectionName 集合名称
     * @param docs[] 内容数组
     * @returns 
     */
    public insertMany<T = mongodb.Document>(collectionName: string, docs: mongodb.OptionalId<T>[]): Promise<mongodb.InsertManyResult<mongodb.Document>> {
        return new Promise<mongodb.InsertManyResult<mongodb.Document>>(async (resolve, reject) => {
            try {
                this.db?.collection(collectionName).insertMany(docs).then(resolve).catch(err => {
                    throw err;
                });
            } catch (err) {
                reject(false);
            }
        });
    }

    public delete<T = mongodb.Document>(collectionName: string, filter: mongodb.Filter<T>): Promise<mongodb.DeleteResult> {
        return new Promise<mongodb.DeleteResult>(async (resolve, reject) => {
            try {
                this.db?.collection(collectionName).deleteOne(filter).then(resolve).catch(err => {
                    throw err;
                });
            } catch (err) {
                reject(false);
            }
        }).catch(err => {
            return err;
        });
    }

    public deleteMany<T = mongodb.Document>(collectionName: string, filter: mongodb.Filter<T>): Promise<mongodb.DeleteResult> {
        return new Promise<mongodb.DeleteResult>(async (resolve, reject) => {
            try {
                this.db?.collection(collectionName).deleteMany(filter).then(resolve).catch(err => {
                    throw err;
                });
            } catch (err) {
                reject(false);
            }
        }).catch(err => {
            return err;
        });
    }

    public update<T = mongodb.Document>(collectionName: string, filter: mongodb.Filter<T>, update: mongodb.UpdateFilter<T>): Promise<mongodb.UpdateResult> {
        return new Promise<mongodb.UpdateResult>(async (resolve, reject) => {
            try {
                this.db?.collection(collectionName).updateOne(filter, update).then(resolve).catch(err => {
                    throw err;
                });
            } catch (err) {
                reject(false);
            }
        }).catch(err => {
            return err;
        });
    }

    public find<T = mongodb.Document>(collectionName: string, filter: mongodb.Filter<T>): Promise<any[]> {
        return new Promise<any>(async (resolve, reject) => {
            try {
                resolve(this.db?.collection(collectionName).find(filter));
            } catch (err) {
                reject(false);
            }
        }).catch(err => {
            return err;
        });
    }

    public aggregate(_collectionName: string, _pipeline: object[]): Promise<any[]> {
        throw new Error('Method not implemented.');
    }

    private connection(DB_CONN_STRING: string, DB_NAME: string): Promise<mongodb.MongoClient> {
        return new Promise<mongodb.MongoClient>(async (resolve, reject) => {
            try {
                if (!this.client) {

                    const client: mongodb.MongoClient = new mongodb.MongoClient(DB_CONN_STRING);
                    await client.connect();
                    this.db = client.db(DB_NAME);
                    this.client = client;
                    console.log("[Mongodb] class inited.");
                }
                resolve(this.client);
            } catch (err) {
                reject(err);
            }
        });
    }
}

JS-SDK引入

emmmmmm内心复杂。
照理来说微信不该对组件编程陌生，这里居然还用半嵌入式页面开发。
既来之，则安之，我把它转为对象引入到项目，这部分有很多大佬都做了，因为没什么技术门槛。

那时候，刚刚初升高。

正值炎热的盛夏。

还蛮羡慕那时候的纯粹的，歌曲的修饰很少，嘀嗒零星的鼓点，可是却再也找不到那时候的热情了。

这一首歌的鸟鸣和蝉鸣的采样，还是那时用着bit并不高的设备录制的，现在想起来突然感觉好像失去了什么东西。

如今，合成器多了采样多了，套路多了，写出来的好像却没有变多。

多少人说，编曲需要天赋，需要什么什么，需要这需要那的。

其实我很想说，你哪里知道的？听谁的，那么我再问，ta又是哪里知道的，谁说的，论证过吗。如果非要刨根问底，那么这世界还有多少是真的？

“被推翻的 以太理论，爱因斯坦的宇宙观？” 我更愿意相信这是一场无休止的战争。（包括我现在的这一句话，都有着一定的时效性）

你拿什么告诉我，这所谓的“天赋绝对论”是正确的。
我不奉行那些不知来源的理论。

那时的我，和现在对比就得出了很明显的结论。

简单和简单的区别，复杂和复杂的区别

这里我不是很想怀旧了，我更想去吐槽一下，那一些 “这不是有人做过了吗？” 还有 “为什么xxx (较有影响力的人)。。。不做？你这个不行的”

可悲的事是，多少“点子”在这样一点点被摧残，泯灭。

这首歌，是我在2020-05-10发布的，很粗糙，但是我觉得是最接近纯粹的唯一一首。

这不是我一个人的故事。

深拷贝和浅拷贝是 JS 基础，很多人（包括我）可能理解两者的区别。
还有记录一下近期开发沙盒的过程。

中数组的深拷贝和浅拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 现在有个数组 list，它里面有“a、b、c”，3 个变量，如下：
const a = {
    name: 'a',
    value: 'a'
};

const b = 'str';
let c = 256;

const list = [a, b, c];
const listCopy = list;
const listDeep = _.cloneDeep(list);
const listClone = _.clone(list);
list.push('d');
a.name = 'new a';
listClone.push('e');
c = 480;
listDeep.push('f');
list[0].value = 'new a';
list[1] = 'new str';

console.log('list', list); // ???
console.log('listCopy', listCopy); // ???
console.log('listDeep', listDeep); // ???
console.log('listClone', listClone); // ???

重要概念

• 基本类型：Null、Undefined、Boolean、Number、String、Symbol。
• 引用类型：Object、Array、Function、Date 等。

基本类型和引用类型的区别：基本类型在内存中是直接存储数据的，引用类型则为一个内存地址，通过这个地址可以得到存储的数据。

结果及注释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/**
 * 为方便讲解和学习，引入 lodash 的深拷贝和浅拷贝函数
 * 以下代码可在浏览器控制台运行
 */
const importJS = document.createElement('script');
importJS.setAttribute("src", 'https://fastly.i5res.com/npm/lodash@4.17.21/lodash.min.js');
document.getElementsByTagName("head")[0].appendChild(importJS);

// 等待 lodash 加载。要在浏览器使用，有什么好的办法吗？
setTimeout(() => {
  if (typeof _ === 'function') {
    // 现在有个数组 list，它里面有“a、b、c”，3 个变量，如下：
    const a = {
      name: 'a',
      value: 'a'
    };

    const b = 'str';
    let c = 256;

    const list = [a, b, c];
    const listCopy = list; // 引用赋值
    const listDeep = _.cloneDeep(list); // 深拷贝
    const listClone = _.clone(list); // 浅拷贝
    list.push('d'); // list、 listCopy（赋值） 受影响
    a.name = 'new a'; // list、listClone（浅） 和 listCopy（赋值） 受影响
    listClone.push('e'); // listClone（浅）受影响
    c = 480; // 都不受影响
    listDeep.push('f'); // listDeep（深）受影响
    list[0].value = 'new a'; // list、listClone（浅） 和 listCopy（赋值） 受影响
    list[1] = 'new str'; // list、listCopy（赋值） 受影响

    console.log('list', list); // [{name: "new a", value: "new a"}, "new str", 256, "d"]
    console.log('listCopy', listCopy); // [{name: "new a", value: "new a"}, "new str", 256, "d"]
    console.log('listDeep', listDeep); // [{name: "a", value: "a"}, "str", 256, "f"]
    console.log('listClone', listClone); // [{name: "new a", value: "new a"}, "str", 256, "e"]
  }
}, 1000);

总结

1. 浅拷贝得到的数组，其内引用类型的地址为原来的地址，基本类型没有引用地址，等同于深拷贝。即：浅拷贝后数组中的引用类型跟随原数组变化。
2. 深拷贝得到的数组，引用类型的地址不为原来的地址，即：其每层引用类型的地址都是新的地址，所有数据变化不与原来的关联。
3. 引用赋值得到的数组，与原来的数组一致，即：list 和 listCopy 指向同一个地址，可以得到原数组的引用地址内的数据变化。

沙盒开发

核心功能

导入模块vm模块

官方文档

主要内容

上下文

这个作为沙盒的运行主体（什么都要往里送）

context

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

//把context包装成proxy对象，来捕捉一些操作
let context = new Proxy(context, {
    set(o, k, v) {
        //...
        return Reflect.set(o, k, v)
    },
    defineProperty: (o, k, d)=>{
        if (
          //权限判断
        )
            return Reflect.defineProperty(o, k, d)
        else 
            return false
    },
    preventExtensions: (o)=>{
        return false
    },
    setPrototypeOf: (o, prototype)=>{
        return false
    }
});

保护类

Proxy
Object
Function
Array
…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//冻结内置对象(不包括console,globalThis)
const internal_properties = [
  'Object',             'Function',       'Array',
  'Number',             'parseFloat',     'parseInt',
  'Boolean',            'String',         'Symbol',
  'Date',               'RegExp',         'eval',
  'Error',              'EvalError',      'RangeError',
  'ReferenceError',     'SyntaxError',    'TypeError',
  'URIError',           'JSON',           'Promise',
  'Math',               'Intl',
  'ArrayBuffer',        'Uint8Array',     'Int8Array',
  'Uint16Array',        'Int16Array',     'Uint32Array',
  'Int32Array',         'Float32Array',   'Float64Array',
  'Uint8ClampedArray',  'BigUint64Array', 'BigInt64Array',
  'DataView',           'Map',            'BigInt',
  'Set',                'WeakMap',        'WeakSet',
  'Proxy',              'Reflect',        'decodeURI',
  'decodeURIComponent', 'encodeURI',      'encodeURIComponent',
  'escape',             'unescape',
  'isFinite',           'isNaN',          'SharedArrayBuffer',
  'Atomics',            'WebAssembly'
];

for (let v of internal_properties) {
    vm.runInContext(`this.Object.freeze(this.${v}); this.Object.freeze(this.${v}.prototype); const ${v} = this.${v}`, context);
}

权限类

isMaster()

1
2
3
4
5
6
7

// SANDBOX_ROOT该环境变量为永久master
vm.runInContext(`Object.defineProperty(this, "root", {
    configurable: false,
    enumerable: false,
    writable: false,
    value: "xxxxxxxx" // 主人的鉴权方式
})`, context);

输入

这边是封装了一个exec的函数

1
2
3
4

//沙盒执行超时时间
let timeout = 500
module.exports.getTimeout = (t)=>timeout
module.exports.setTimeout = (t)=>timeout=t

1
2
3

module.exports.exec = (code) => {
    return vm.runInContext(code, context, {timeout: timeout})
}

输出

直接用一个try{}包起来，万事大吉

道高一尺

1
2
3
4
5
6
7
8
9
10
11
12
13
14

//防止沙盒逃逸
Function.prototype.view = Function.prototype.toString
Function.prototype.constructor = new Proxy(Function, {
    apply: ()=>{
        throw Error("想跟妾身斗，汝还差得远呢。")
    },
    constructor: ()=>{
        throw Error("想跟妾身斗，汝还差得远呢。")
    }
})
Object.freeze(Object)
Object.freeze(Object.prototype)
Object.freeze(Function)
Object.freeze(Function.prototype)

来自大学课程的一封启示。

在专攻硬件这条路上算是越走越远了啊，硬件会不会要走得更远一点？因为要接触底层，那么更需要学会一些强类型的语言。C，我来了

纯属是个人笔记，想到多少写多少，各位看官勿怪。
写了一部分以后就没写了，东西很浅，就是入个门。

在一切的最初

近距离神魔打架

言归正传

编写C++的一些IDE一般有 Dev-Cpp, CLion, Visual Studio

Microsoft Visual Studio 应该算是比较熟悉的了，当然不是 Visual Studio Code。

小项目使用 Dev-Cpp
大项目使用 CLion

在学习一门语言的时候我们总是习惯去输出他。

1
2
3
4
5
6
7

#include <iostream>
int main() {
float a,b,c,d,e,f,g;
scanf("%f %f %f %f %f %f %f", &a,&b,&c,&d,&e,&f,&g);
printf("%.2f",(a+b+c+d+e+f+g)/7);
return 0;
}

这其实就是一个简单的均值求法。

每一个语言都有它的魅力，比如C++，令人难以理解的运算速度是超越其他语言的绝对优势。

语言经典的循环

每一个语言必不可少的东西，进阶后就是迭代器，遍历的算法在大型项目中非常常见（结论来自我做过的其他项目）

for()

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>
int main() {
int a;
scanf("%d", &a);
for (int i = 0;i < 5;i++){
printf("%d", a);
if (i < 4) printf(" ");
a = 2 * a + 1;
}
return 0;
}

求这个分数序列的前n项之和

题目：有一个分数序列 q1/p1,q2/p2,q3/p3,q4/p4,q5/p5,…. ,其中qi+1= qi+ pi, pi+1=qi, p1= 1, q1= 2。比如这个序列前6项分别是2/1,3/2,5/3,8/5,13/8,21/13。求这个分数序列的前n项之和。

样例输入
2
样例输出
3.5000

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
int main() {
int n;
float p[100], q[100], s = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
p[i] = (i > 0) ? q[i - 1] : 1;
q[i] = (i > 0) ? p[i - 1] + q[i - 1] : 2;
s += q[i] / p[i];
}
printf("%.4f", s);
return 0;
}

从键盘输入5个数，找出其最大数并输出

样例输入
2 3 4 7 5
样例输出
7

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
int max(int a, int b) {
return a > b ? a : b;
}

int main() {
int m = 5, a[m], t = 0;
scanf("%d %d %d %d %d", &a[0], &a[1], &a[2], &a[3], &a[4]);
for (int n = 0; n < m; n++) {
t = max(a[n], t);
}
printf("%d", t);
return 0;
}

求n的正整数的阶乘的和

样例输入
5
样例输出
153

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
int main() {
long long int n, s = 0;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
int c = 1;
for (int v = 1; v <= i; v++) {
c *= v;
}
s += c;
}
printf("%lld", s);
return 0;
}

绕啊绕绕啊绕绕啊绕

描述

请统计某个给定范围[L, R]的所有整数中，数字2出现的次数。
比如给定范围[2, 22]，数字2在数2中出现了1次，在数12中出现1次，在数20中出现1次，在数21中出现1次，在数22中出现2次，所以数字2在该范围内一共出现了6次。

样例输入
2 22
样例输出
6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>
int count(int n) {
int i;
for (i = 0; n > 0; n /= 10)
{
if (n % 10 == 2) i++;
}
return i;
}

int main() {
int a, b, c = 0;
scanf("%d %d", &a, &b);
for (int i = a; i <= b; i++)
{
c += count(i);
}
printf("%d", c);
return 0;
}

你真的懂语法吗？

do while()

根据条件来循环语句。
阶乘相加的算法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 题目：求1!+2!+3!+4!+…+n!的结果。n！=n*(n-1)*(n-2)*...2*1
#include <iostream>
int main() {
int a;
while(scanf("%d", &a) != EOF) {
int d = 0;
for (int b = 1; b <= a; b++) {
int e = 1;
for (int c = 1; c <= b; c++) {
e *= c; 
}
d += e;
}
printf("%d\n", d);
} 
return 0;
}

库和包（我习惯的叫法）

OJ平台上并不允许引用其他的包，所以使用基础方法去解决一些问题的时候会很头疼（平常倒也不用那么死脑筋，有轮子不用是**，不过学习的时候就得好好学）

math.h stdio.h …

在哪里？自动生成在程序目录里面吗？
其它库函数标准文件呢？
那为什么，生成目录没有这文件、、却可以运行？

不完全统计，C语言标准库中的头文件有15个之多，所以我主要介绍常用的这四个头文件stdio.h，string.h，math.h，stdlib.h。

他们都被存放于用户所带的C:\Program Files\Microsoft Visual Studio\VC98\Include

他们各个被定义的方法都不同，已经有很多教材对这些进行了整理。（那么这里就不多做赘述了）

scanf()有什么特点

如果要单独拿一个字符（数字）

1
2
3
4
5
6
7
8

#include <iostream>

int main() {
int a, b;
scanf("%1d%1d", &a, &b); // 38
printf("%d和%d", a, b); // 3和8
return 0;
}

函数

不同于数学中的函数的是，他将步骤进行分开，主要放大了其中的运行逻辑。

1
2
3
4
5
6
7
8
9
10
11
12

// 下面有所体现
#include <iostream>

void fn() {
// 这里定义了一个 fn() 函数
return;
}

int main() {
fn(); // 这里调用了fn()
return 0;
}

其中，能看出 void fn() “fn”是函数名， “void”是函数将要返回的类型。

int main(void) 是标准形式，这么写时，结尾要加 return 0; 其实怎么写都可以，主要是看你的编译器。（来自“百度”）

最近「微信键盘」开启了内测，我看到挺多网友讨论的，于是前几天下载下来尝试了一下，今天也来跟大家分享一下使用体验。

首先需要说明的是，我对一个输入法的要求，其实就只有两点：

1. 精准。要能够切实提升我的输入效率，这是一个输入法最核心的竞争力。如果经常打错字，或者无法给出精准的候选词，那我为什么不自己开发一个本地的拼音输入法？

2. 隐私。输入法里面，包含了太多的个人信息，身份证号、手机号码，银行卡号，居住地址，基本上所有关于你的信息，输入法都有能力获取到；如果一个输入法不能保护隐私，那么你在任何其他地方做的任何保护隐私的努力都形同虚设。

在开始评测之前，说一下我当前使用的输入法：

• 电脑上我用的是 macOS 系统自带的双拼输入法，没有额外的词库，只有自己录入的常用的短语（如收货地址，开票信息等）

• 手机上我使用的是 MIUI 搜狗输入法小米版，使用的是全拼，并且开启了隐私模式。

核心体验

有人可能会觉得奇怪，为什么我电脑上要用「双拼」？这完全是因为 macOS 系统自带的拼音输入法与第三方输入法（如搜狗）差距太大了，搜狗的云词库和联想功能不是一般的强大，而系统输入法做不到；为了不依赖这种联想功能，我选择了双拼输入；而手机上由于键位有限，双拼并没有太大的优势，所以没办法用了搜狗。

说回微信键盘，经过几天的体验，我认为它的输入体验基本上可以满足我个人的要求了。比 macOS 系统自带的拼音输入法要强，但与搜狗相比还是差了点。在使用微信键盘的时候，一天总有那么几次，它没法给出我需要的候选词，或者它有这个候选词，但排列太靠后了。每次出现这种情况，我都有一种挫败感，但使用搜狗却很少出现这个问题；或者说，我在使用搜狗的时候，在它没有给出合适的候选词的绝大多数情况下，我自己内心也会觉得“它确实联想不出来”，而在使用微信键盘的时候，我内心会觉得“你明明可以给出合适的候选词，为什么没有？”

当然，这也可能与我使用微信键盘的时间还太短了有关，做词语联想，还是需要一定的数据量做训练；不过当前的事实就是：基本满足需求，还有改进空间。

隐私

上面我们提到，输入法有能力获取你所有的隐私信息；不过，能不能和做不做是两码事，很多时候，输入法尊不尊重你的隐私，我们普通人是完全没有保障的。不过，作为一个程序员，我还是有能力对 App 做一些分析。我在 B 站和公众号上看到不少这样的言论：微信键盘的联想功能要联网，**龙肯定把我的输入信息传到服务器了，扯什么隐私？

接下来，我将从技术角度，比较一下「微信键盘」和「搜狗输入法小米版隐私模式」在隐私方面的不同之处。

备注：微信键盘版本 0.9.0，搜狗输入法小米版版本 9.5.21.2111192114

隐私权限

在 Android 系统上，如果一个 App 要获取某些敏感的信息，必须提前向系统声明相关的权限；比如读取设备ID，获取联系人信息等等。我反编译了微信键盘和搜狗输入法，对比一下二者声明的权限，表格如下：

通过上面的表格可以看到，微信键盘总共申请了 9 个权限，搜狗输入法申请了 41 个权限；其中比较高危的权限我用红色标记了出来：

• 访问麦克风；虽然输入法需要这个权限实现语音输入的功能，但理论上这个权限可以实现录音。

• 获取设备ID；这个权限可以用来实现跟踪功能，可以通过设备ID关联到具体的人，对隐私保护至关重要。

• 访问sdcard；可以访问到 sdcard 中其他 App 的信息，也可以实现追踪。

• 读写联系人；虽然这个权限大概是用来输入联系人姓名的，但这样它就能读取你所有联系人信息。

• 读写短信；虽然这个权限大概是用来输入短信验证码的，但这样它就能读取你的短信。

• 获取地理位置；想不通输入法要这个权限干什么。

简单比较我们就能得知，搜狗输入法申请的权限将近微信键盘的 5 倍！！其中一些关键的权限，微信键盘完全都没有获取，**龙说微信键盘要保护隐私，从这个角度来说，他做到了。

有人会问，百度输入法和讯飞输入法咋样呢？加上百度之后，我27寸显示器，截图截不下了…它申请了 48 项权限，搜狗有的它也基本都有，搜狗没有的它也有！讯飞也好不到哪里去，它申请了 45 项权限。（作为对比，Google 自家的输入法 GBoard 申请了 22 项权限） 可以说，传统的输入法厂商，在权限申请方面，都是半斤八两，而微信键盘在他们面前，绝对是一股清流！！

用户跟踪

我们经常会发现，跟某人聊天提到了某个东西，淘宝上就会出现相关的广告。曾经有这样一个梗：上一秒在微信上打完笑死了，下一秒打开淘宝已经给我推荐棺材。

对用户隐私来说，有一点其实也很重要，那就是防止追踪。很多时候，App 不可避免地会获取到我们很多信息，除了输入法之外，比如购物 App 能获取你的订单信息、地址等，再比如绝大部分 App 可能要收集崩溃日志来改进程序；只要保证 App 获取的是匿名信息，它们能做的事就非常有限。在我们的信息不可避免地要被获取的情况下，退而求其次，防止被追踪也是非常有效的办法。

如果某个 App 可以获取我们的隐私信息，但它没有办法把这个信息传递给别人，那么它能做的事就非常有限；毕竟，如果一个输入法给自己加一个淘宝商城，用户八成是要把它卸载。

在设备跟踪方面，最常见的方法就是：imei / android_id / oaid / 自己生成 id 放 sdcard；继续反编译微信键盘和搜狗输入法：

如果某个 App 可以获取我们的隐私信息，但它没有办法把这个信息传递给别人，那么它能做的事就非常有限；毕竟，如果一个输入法给自己加一个淘宝商城，用户八成是要把它卸载。

在设备跟踪方面，最常见的方法就是：imei / android_id / oaid / 自己生成 id 放 sdcard；继续反编译微信键盘和搜狗输入法：

说实话看到这个结果我是非常震惊的，在获取用户 ID 方面，微信键盘竟然全都是 0！反观百度输入法，为了跟踪用户简直无所不用其及，在 /sdcard 不同地方竟然存了四份！！

另外，在反编译微信键盘的时候，我意外发现如下代码：

这个键盘使用了一个叫 qimei 的 SDK，它刻意把 imei / imsi / android_id / mac addr / process info 给禁用了！

当然，这个结果也没有办法完全保证微信键盘没有跟踪用户，它至少还有这些方法：

1. 直接与微信交互获取用户信息；毕竟微信人手一份，微信键盘要是要跟踪用户，没必要用上面那些手段；这一点是怀疑，无证据。

2. 通过 JNI 的方式在 native 层获取 device_id / imei / android_id 等信息；这也是有可能的，不过这需要动态分析，暂时没有精力去处理。

其他

我看到有不少人调侃微信“小而美”，微信键盘安装包 150M，安装完毕后占用空间 780M，因为空间占用比较大而说它不好，就像是说鲁迅普通话不标准进而认为他的文章都是垃圾一样。对我来说，存储空间占用是最最廉价的属性了，原神占用我手机 20G，丝毫不影响我认为它是目前最好玩的手机游戏。

有一说一，微信键盘安装包约 150M，里面 80% 的空间存放的是它的本地词库！！

我不清楚微信键盘为何要放这么大一个词库在安装包里面，不过，如果它将来出一个功能，可以不联网使用，仅使用本地词库，一定会是一个杀手锏。

总结

1. 微信键盘界面简洁，核心输入功能可以满足需求，不过还有改进空间。

2. 隐私保护方面吊打其他巨头同行，只有某些开源输入法可以媲美。

3. 毕竟还是 beta 版，某些臃肿的功能还没有时间开发，将来会不会搞得花里胡哨犹未可知。

总的来说，这款键盘非常值得体验。

如果微信键盘现在停止开发，或者后续加入了各种权限和隐私跟踪功能，我将永远停留在此版本，用到 Android 系统倒闭。

新报

现在是 2022年10月31日 我使用微信键盘已经有2个月了，再来说说各人看法。

精简依旧，词库的缓存回收好像也做好了，除了 语音输入 剪切板 几乎无可挑剔。

Window版本的输入法更新咯！

这个是展现在我的状态栏中，其次是简约的风格：

我是真的太喜欢了，vocal！

kan’kan’zhe’g’da’zi’feng’ge 看看这个打字风格

能和手机端联动的进行剪切板同步！

QQ Web Api 收集

web api 是需要 cookie 或 csrf-token(bkn) 才可正常访问，用于实现一些扩展功能的 api
如果你知道一些尚未收集到的有用api，欢迎提交pr到这个文件

项目介绍

它，只是一个计算器。但是，使用了新拟态的样式设计。

它能用来做什么？逢年过节遇到三姑六婆，拒绝叫不出口的尴尬！轻松搞定亲戚关系～

由于工作生活节奏不同，如今很多关系稍疏远的亲戚之间来往并不多。因此放假回家过年时，往往会搞不清楚哪位亲戚应该喊什么称呼，很是尴尬。然而搞不清亲戚关系和亲戚称谓的不仅是小孩，就连年轻一代的大人也都常常模糊混乱。

主要是？轻量！轻量！还是轻量。

链接地址

https://kinship.i5res.com/

亲属是基于婚姻、血缘和法律拟制而形成的社会关系。亲属关系包括夫妻、父母、子女、兄弟姊妹、祖父母和外祖父母、孙子女和外孙子女、儿媳和公婆、女婿和岳父母、以及其他三代以内的旁系血亲，如伯、叔、姑、舅、姨、侄子女、甥子女、堂兄弟姊妹、表兄弟姊妹等。

亲属称谓指是以本人为中心确定亲族成员和本人关系的名称，是基于血亲姻亲基础上的亲属之间相互称呼的名称、叫法。汉族的家族亲属关系条理分明尊卑有序：比自己长一辈的称呼有姨姑舅叔伯，同辈的有兄弟姊妹、堂表亲等等，下一辈有甥侄等等。中国人由于姻亲而产生的亲戚关系相当庞杂，“祖宗十八代”、“五服”、“六亲”、“九族”让人难以区分，其派生出的各种称谓也是中华文化的一大特征。

如今由于工作生活节奏差异，很多关系稍疏远的亲戚之间来往并不多，年龄差异长幼辈分模糊。春节拜年走亲戚遇到七大姑八大姨，往往会搞不清楚哪位亲戚应该喊什么称呼，很是尴尬。不仅小孩搞不清亲戚关系和亲戚称>谓，就连年轻一代的大人也都常常模糊混乱。

“中国亲戚关系计算器”为你避免了叫错、不会叫亲戚的尴尬，收录了中国亲戚关系称呼大全，只需简单的输入即可完成称呼计算。称呼计算器同时兼容了不同地域的方言叫法，你可以称呼父亲为：“老爸”、“爹地”、“老爷>子”等等。让您准确的叫出亲戚称谓，理清亲属之间的亲戚关系，轻松掌握中国式的亲戚关系换算，让你更了解中国文化。

算法开源

感谢mumuy大佬的项目！

本项目致力于让更多人了解中国传统文化，学习各式各样的中国亲戚称谓。本人深感项目的完善仅凭一己之力是远远不够的，如果你对此感兴趣，欢迎关注本项目。你也可以通过本项目提供的方法和教程，打造更符合自己使用习惯的亲戚计算器版本。

算法基于「MIT许可协议」开源，除需在源码中保留版权信息和许可声明外，你有权利使用、复制、修改、合并、出版发行、散布、再授权及贩售软件及软件的副本。算法持续更新中，如发现错漏或有想法建议可在此 反馈问题。

算法实现

常见问题

市面上同类型的算法基本以 “称谓-直接关系-称谓” 的方式实现，如：

1
2
3
4
5
6
7
8
9
10
11
12

"爸爸": {
    "爸爸": "爷爷",
    "妈妈": "奶奶",
    "哥哥": "伯父",
    "弟弟": "叔叔",
    "姐姐": "姑妈",
    "妹妹": "姑妈",
    "丈夫": "未知",
    "妻子": "妈妈",
    "儿子": {"older": "哥哥", 'middle': "我", "younger": "弟弟"},
    "女儿": {"older": "姐姐", 'middle': "我", "younger": "妹妹"}
}

这样的结构主要有以下问题：

1. 无法跨代直接查询，如：如何知道“舅妈的婆婆”是谁？
2. 无法逆向查询称谓，如：“表哥的妈妈”的妈妈是“舅妈”、“姨妈”还是“姑妈”
3. 数据结构过于臃肿, 如：某个节点下可能会出现多个“未知”
4. 无法兼容多种称呼，如：各地称呼不尽相同，“爸爸”也可以叫“父亲”、“爹地”
5. 无法进行关系拓扑，如：“舅妈”和我什么关系？

本算法的原理

采用 “关系链-称谓集合” 哈希对的方式建立数据库，映射亲戚网络中的每个节点和自己的关系

数据结构

1
2

'h':['老公','丈夫','先生','官人','男人','汉子','夫','夫君','相公','夫婿','爱人','老伴'],
'h,f':['公公','翁亲','老公公'],

每个称谓都可以找到相应的关系链，每个关系链同时有对应的称谓集合，这里需要引入自己“发明”的特殊语法标记

语法说明

1
2

【关系】f:父,m:母,h:夫,w:妻,s:子,d:女,xb:兄弟,ob:兄,lb:弟,xs:姐妹,os:姐,ls:妹
【修饰符】 1:男性,0:女性,&o:年长,&l:年幼,#:隔断,[a|b]:并列

例如：

“f”对应着爸爸，那么：”f,m”对应着奶奶,”f,f”对应着爷爷；

这样在查询关系的时候，只需要对关系链进行计算就好了，而不是对称谓进行字典查找

算法思路

1. 当用户输入“舅妈的婆婆”，可以分解出两个对象“舅妈”和“婆婆”（前者的婆婆）

2. 从“关系链-称谓集合”映射关系可知，这两个对象的关系链分别是：”m,xb,w”和”h,m”,合并后的关系即：”m,xb,w,h,m”

3. 此时关系链会出现冗余，需要进一步处理：

   • “w,h”表示“老婆的老公”，即自己，可直接将关系链简化成：”m,xb,m”

   • 同理，”xb,m”表示“兄弟的妈妈”，即自己的妈妈，可将关系链再次简化为：”m,m”

   • 当无法进一步简化时，就得到了“最简关系链”，将其带入亲戚关系数据库查询，便可知”m,m”即为自己的“奶奶”

4. 这样就将复杂的关系链转换成直接关系了，除此之外还可根据“关系链-称谓集合”反向通过称呼找到关系；

实现细节

如何实现关系链的简化？

关系链为字符串，用正则表达式即可按情形匹配，同时做到“替换”的操作。由于所有非直接的关系，都是存在关系链表达的冗余。虽然冗余可能多层且复杂，只需要考虑两层关系中的去冗余，反复处理即可。

某些多层关系可能未必对应一种关系，如何解决关系的不唯一？

“爸爸的儿子”不一定是自己，也可能是自己的兄弟。在语法中引入了“隔断”和“并列”语法，可以借助正则表达式将此类不唯一的关系拆分为多组，每次再单独带入递归求最简解即可。

每个节点离自己远一层关系，节点数据便翻倍，如何解决数据量过大的问题？

中国的亲戚关系存在一定规律，旁系分支大体由 分支节点 及其 子代关系 ，我们只需记录 分支节点 和 子代关系 即可。如：“舅表哥”和“堂哥”两者在和自己的关系链上存在一定相似，没必要记录两者所有关系。只需知道“舅表哥”是“舅舅”的后代，而“堂哥”是“叔伯”的后代，那么“舅表哥”和“堂哥”的所有后代及姻亲数据可以只存3部分。即：

舅表哥关系数据 = 舅舅（分支节点） + 哥哥关系数据（子代关系）；

堂哥关系数据 = 叔伯（分支节点） + 哥哥关系数据（子代关系）；

这样的关系有很多，如：“舅表”、“姑表”、“从堂”、“姑表叔表”等等，对关系数据进行拆分复用，即可以达到压缩数据量。同时在脚本运行中对 分支节点 和 子代关系 进行拼接即可组合出数据库。

关于其他

他们都在用：

查询网 http://www.ip138.com/chengwei/
在线查询网 http://qinshu.supfree.net/
在线工具 http://www.atool.org/relateship.php
有道语文达人 http://dict.youdao.com/k12yuwen/html/relation.html
小米MIUI系统计算器 http://www.miui.com/
小米MIUI网页版本 http://www.miui.com/zt/calculator2016/dist.php
符号库 http://www.fuhaoku.com/tool/qinqiguanxi.html

我们知道，原版Xposed框架(rovo89写的那个)

在ART运行时上的实现方式是，用AOSP的代码，将ART部分进行魔改加入xposed方法的执行逻辑。
这种方法技术上行得通的原因在于Android系统对libartso的要求就是实现三个方法(主要是JNICreateJavaVM)。
然而，原版Xposed框架在80系统难产在90停更，技术上很大的原因在于ART越来越复杂，不仅要修改libart.so还要改dex2oatlibjit-compiler.so等一堆东西…导致维护起来基本上就失控了。
但ARTapex的出现似乎让这玩意出现了转机。
Google 在 Android 10 上引入了 project mainline 很多模块都独立成了可单独安装的apex，其中就包含runtime，Android 11更进一步，ART被完全独立了。
因此，原版Xposed的那种，用AOSP魔改一个ART来替换官方ART似乎又成为了一个非常好的选择，
因为，安装一个apex就和安装一个apk一样简单!

因为最近的一些需求，我不得不对鉴权反复翻检。如是

我通过了一些简单的例子对OAuth全面理解。其实并不高深，大约10分钟，就可以完全理解它。

OAuth 2.0

注册Github OAuth

最后如图

初步握手，获取Code

接口地址

https://github.com/login/oauth/authorize

请求参数

最后拼接

请求后他能给我些什么？

?code=0dbc9506a2a4a0c1a1c9&state=1

请求鉴权回调返回access_token

接口地址

https://github.com/login/oauth/access_token

请求参数

最后拼接

请求后返回？

1
2
3
4
5
6
7
8
9

{    
  "access_token":"ACCESS_TOKEN",
  "token_type":"bearer",
  "expires_in":2592000,
  "refresh_token":"REFRESH_TOKEN",
  "scope":"read",
  "uid":100101,
  "info":{...}
}

使用Github的RSET API进行操作

具体参见: GitHub’s rest API documentation

OAuth的持续发展

是什么

https://blog.csdn.net/a595077052/article/details/118996218

OAuth 2.0 是一种开放协议。
OAuth 2.0 的标准是 RFC 6749 文件。

举例：我们都在网站或者手机应用中见过 “谷歌登陆” 和 “绑定 Facebook“ 这样的按钮。如果你点击这个按钮，就会有一个窗口弹出并显示“这个应用想要访问你的公共个人主页、通讯录……“，同时它会询问你是否授权。概括而言，这就是 OAuth

如今过半数的APP都使用到了这一鉴权方式，他相比对OAuth 1.0的安全性有大幅度提升

发展历程

• 2007年发布了OAuthCore 1.0：此版本的协议存在严重的安全漏洞
• 2009年6月发布了OAuthCore 1.0 Revision A：修复了前一版本的安全漏洞，并成为RFC5849
• 2010年4月发布了OAuth2.0，是OAuth协议的下一版本，但与OAuth 1.0版本互不兼容。

所以我们现在可以只关注 OAuth2.0

OAuth core docs: https://oauth.net/

单点登录

开源项目jwt有简单的描述。

很简单的剖析一下，

一、假设你有很多服务器（集群），你需要一个所有集群都认可的鉴权。

二、你需要携带这份密钥行进在各页面之间。

如果解决这两大问题，那么就可以实现了。

jwt是目前很多公司的解决方案（包括我的学校）

其他第三方平台的鉴权方式

Gateway：网关鉴权

在小时候，因为家庭管教的严格，限制很多电子产品，在想方设法软磨硬泡下被答应了使用手机听歌。

但在那个无忧无虑的年纪，倒是很会苦中作乐，这也是我难以忘怀的一段经历了。

与音乐结缘，无花无果，无你无他。热爱音乐，也热爱生活！

专题の练习

单耳扒带练习

Ninelie

时间：2022年12月2日

霍元甲

时间：2022年11月28日

奥日（Ori）

时间：2022年11月19日

一个特殊的日子

挺特殊的一个日子，祝我的好兄弟生日快乐！！

曲子的最后有一段《生日快乐》的变调，应该没多少人能听出来吧。

原神《神女劈观》

时间：2022年11月12日

当时看到这个片段感觉很惊艳。
因为我的游戏刚开始下载的时候是英文配音！！
在任务进行到PV播放的时候，突然出现的汉语让我猝不及防。

另外，我觉得真的很有味道。

天衡山里本有一处村落，村中有对感情很好的夫妻。有天妻子出门采药，被魔物捉走，丈夫也因此变得疯疯癫癫。魔物威胁村民把村中小孩供奉给他，村民十分恐惧，有个小姑娘却主动请缨，身藏一把驱魔剑，进入魔物的老巢与其苦战，最后将魔物击败。后来，姑娘因资质过人被仙家收留，但也无缘再入尘世。

原神·奥摩斯港 OST

时间：2022年11月11日

很折磨，真的。。。
万幸…

League of Legends Medley

联盟永垂不朽

すずめの戸締まり 扒带

现在是2022年10月6日，国庆假期结束前一晚。

Right Above It（单耳扒谱）

冲！！！！

这是一次练习，用到的音源也都是自带的，因为我电脑内存是在不允许我去外置了QWQ

我的剩余储存

FLEX 合成器（自带的）

Fl Studio工程截图

艾尔大陆（游戏《艾尔大陆》 原声带）

也是练习！！也是练习！也是练习！！！

日落维京

登峰造极

启程（Piano）

抉择吧

日常练习

2022年11月6日

2022年8月30日练习

三全音

2022年8月28日练习

布鲁斯，这种风格果然还是不太会写。

2022年8月27日练习

有种史诗的感觉了

2022年8月24日练习

2022年8月20-21日练习

夏日pop + 爵士 这种味道是什么样的，漫无目的的探索，是炎炎夏日对生活的告白。

使用了一个很仙的pad，没错，我花了30分钟捏出来的，使用的合成器是serum，我打算叫他spaceship
就是其中那个 咻~~~~ 的 rise，个人很喜欢，它应该有更大的用途的。

2022年8月14日练习

6152觉得很不错的一个大调和弦，练习分轨如下

他们加起来听起来像这样

在进行上可能欠缺一些东西，但是总体来说还是很整体的lol

2022年8月13日练习

一个大调4563，几个分轨如下

他们加在一起听上去像这样…

2022年7月17日练习

中世纪和弦一个大胆的尝试

用了一个小降，听上去感觉像那么回事了，鼓点是随便写的，仍有很多欠缺的地方。

2022年7月16日练习

这个是一个简单的大小调add转换的练习，还有很多欠缺的地方。

2022年7月16日trap练习

2021年7月12日 一位受害者

关于这个西瓜皮

其实不难猜，和爬虫挂钩的那无非就是无头浏览器。

Puppeteer已经是蛮成熟的一个无头了，几乎能满足开发的所有需求，而且该项目由Google团队开源长久维护，有着丰富的社区。（简而言之，你踩到的坑，别人都踩到过，如果！！哪一天你踩到了一个没有人踩到过得坑，那么务必来找我，哈哈哈哈哈）

玩这个东西也挺久的了，在一些开源项目里有做过很多贡献，其中不乏有借了Puppeteer的光啊。

踩坑笔记

这里主要记录了，日常开发以及团队项目开发期间遇到的一些问题，所以这篇文章将处于长期更新维护的状态。
如有问题，欢迎底下评论区进行提问，博主24H在线，不出意外的话5分钟内会有回复的。

CentOS 的一些特殊配置

报错：

1

/../node_modules/puppeteer/.local-chromium/linux-515411/chrome-linux/chrome: error while loading shared libraries: libatk-bridge-2.0.so.0: cannot open shared object file: No such file or directory

按照他的意思是没有找到相关依赖库，这玩意简单了。

CentOS解决方法：

请求时出现 net::ERR_TUNNEL_CONNECTION_FAILED

复现：

• 可用代理（测试完整）
• 完整请求头

测试上百次依旧报错 net::ERR_TUNNEL_CONNECTION_FAILED

已查阅：
Windows10错误：https://answers.microsoft.com/en-us/windows/forum/all/getting-error-errtunnelconnectionfailed-while/f8d8b61f-a875-4d57-8a4f-3427a0e783c6
Chrome错误：https://www.techbout.com/err-tunnel-connection-failed-error-in-chrome-39692/
Puppeteer错误：https://vi.sandiegocsta.org/488310-puppeteer-chromium-proxy-err-tunnel-PDNJOM
Puppeteer错误：https://www.xknote.com/ask/60ef8c45582ca.html

最后。

在Puppeteer的issues中找到相关记录，维护团队回复：Hey @Yom92 That error is coming straight from Chromium. There is not much we can do on our side.
具体参见：https://github.com/hardkoded/puppeteer-sharp/issues/1202#issuecomment-509187809

要而论之。

在需要代理的无头请求时，应当注意Chromium的特性，那么就没有其他的替代方案了。
对！我还没想到，如果你有，麻烦大佬下方评论区畅所欲言。

实现

无头的作用想必大家都有所了解了，那么他能用来做些什么呢？
博主在这里尝试了几个简单的请求，不同于axios的是，Puppeteer可以等待Dom和页面加载。

博主常用该类来进行SEO词尾优化，提高命中率。

原神官网抓取和操作

暂无更方便的获取cookie的办法，所以只能要求用户自己获取米游社的cookie，在请求的时候puppeteer携带cookie就能完成，角色查询，签到等任务。

相关项目：

剖析一下机器人即可，很巧妙的利用了无头进行图片渲染👍

无头渲染图片

作为Canvas的替代方法，顺便一提，应该没有人喜欢用Canvas去渲染图片吧？那叫一个折磨啊，H5不比画板香吗？

使用 Linux 搭建 RTMP 流媒体服务器，进行在线直播。

搭建串流服务器

好用的Docker镜像，比较好用，比较简单，比较方便，比较容易使用。
博主使用的是 CentOS 8.0 系统，没有预装 Docker

在开始安装之前，有必要提醒，更新yum的下载源！！

至此！

你拥有了一个可以收发媒体流的RTMP服务端

详情参见: alqutami/rtmp-hls

配置OBS串流

下载与安装就不需要再赘述了吧

官方地址

OBS串流设置

右键左上方'文件'

找到左侧栏目'推流'选项

客户端

Vite框架

博主使用Vite框架，这并不代表播放HLS流媒体只能使用Vite前端框架。

为了方便，在这里就不赘述Video.js的使用方法了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<html lang="en">
<head>
<style class="vjs-styles-defaults">
.video-js {
width: 300px;
height: 150px;
}

.vjs-fluid {
padding-top: 56.25%
}
    </style>
<style class="vjs-styles-dimensions">
.player-dimensions {
width: 720px;
height: 405px;
}

.player-dimensions.vjs-fluid {
padding-top: 56.25%;
}
    </style>
<meta charset="UTF-8">
<title>HLS Live Streaming</title>
<link href="https://vjs.zencdn.net/7.5.5/video-js.css" rel="stylesheet">
<script src="https://vjs.zencdn.net/7.5.5/video.js"></script>
</head>
<body>
<h1>HLS Player</h1>
<video id="player" width=1280 height=720 class="vjs-default-skin" controls>
<source src="http://hls.i5res.com/hls/zj520.m3u8" type="application/x-mpegURL"></source>
</video>
<script>
var player = videojs('#player');
</script>
</body>
</html>

Vite初始化

关于如何使用NPM进行初始化，请参见: https://vitejs.cn/guide/#scaffolding-your-first-vite-project

这里以NPM做简要概述:

初始化程序

随后跟随步骤完成项目创建即可。

LarchLiu/vue3-video-player

安装包文件

1
2
3
4
5
6
7
8
9

import { createApp } from 'vue';
import App from './App.vue';
import Vue3VideoPlayer from '@cloudgeek/vue3-video-player';
import '@cloudgeek/vue3-video-player/dist/vue3-video-player.css';


createApp(App).use(Vue3VideoPlayer, {
lang: 'zh-CN'
}).mount('#app');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<script setup lang="ts">
import HLSCore from '@cloudgeek/playcore-hls';
import { reactive } from 'vue';

const options = reactive({
sources: [
{
src: "http://hls.i5res.com/hls/zj520.m3u8",
type: "application/x-mpegURL",
},
]
});

</script>

<template>
<vue3-video-player :core="HLSCore" :options="options" :src="options.sources" title="大猫咪的直播间">
</vue3-video-player>
</template>

预览地址

RTMPS适配SSL进行推流

博主尝试过为流加密传输，也就是RTMPS的协议，但！！！

缓存更新太慢，博主赶时间。所以使用Nginx反代来实现伪加密。

访问 https://stream.i5res.com 就等于访问了 http://hls.i5res.com:8080

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

server {
  listen 443 ssl;
  listen [::]:443 ssl;
  server_name stream.i5res.com
  access_log /data/wwwlogs/stream_nginx.log combined;
  index index.html index.htm index.php;
  root /data/wwwroot/live;

  #error_page 404 /404.html;
  #error_page 502 /502.html;

  # SSL
  ssl_certificate_key /data/cert/stream/private.key;
  ssl_certificate /data/cert/stream/full_chain.pem;

  ssl_session_timeout 1m;
  ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
  ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
  ssl_prefer_server_ciphers on;

  location ~ / {
    proxy_pass http://hls.i5res.com:8080;
  }
}

video.js 出现很多错误

把video.js拆开来…..一言难尽，上世纪的东西说实话就算功能再强悍其兼容性也像一坨散沙屎
最好的办法，就只有找寻其他替代方案，博主当前也在寻找，如果你找到了，可以在评论区留给我！！！感谢！！！

我学习了一下母带管理。
算是比较的有成效（相对而言，不积小流，无以成江海嘛）

我想用这首音乐描述一个转折（恒星时刻）
更多灵感的参与与我的个人机遇和生活有关，自安于弱，而终于弱矣；自安于愚，而终于愚矣。

这首歌用的主要音色是吉他，也给足了泛音的空灵。

初成曲之

常规的混音流程是先确定几个主要乐器的电平和动态然后冻结，其它乐器以主要乐器为参考进行调节。然后本人做混音也不是特别的好（和专业的远远不能比，能听就行的那种），但做下来多多少少还是积累了一些经验的。
然后因为每个人的混音方法和风格多多少少是有些不同的，就不把整个体系都阐述出来了，这里就罗列一部分tips：

1. 能不把问题留给混音就不要留给混音。换句话说，在编曲的时候就要考虑到混音。如果你是一边做一边混的，可能对这一点深有体会。我这边是先把整个编曲弄好再考虑混音，在实际操作中就会发现很多难以解决的问题。说到底，编曲的时候可能有太多的东西想要加到乐曲里面，而这不被混音所允许。这也说明了一首曲子不是你想加什么进去就加什么进去，硬塞一些东西进去只会让混音变糊。
2. 谨慎使用EQEQ对音色造成的破坏其实是很大的，±3dB的增益量甚至可以产生一个质感不同的音色。我的建议是在制作音色的时候就考虑好频段的分配，避免大量使用EQ。然后一个比较有争议性的话题是电平极低的一些频段信号是否要滤除（所谓的“切干净”），我这边是倾向于切干净的（在非专业的条件下，这些极弱的信号可能会在母带过程中被放大产生失真）。EQ我个人偏向于使用Fabfilter的Pro-Q和Pro-Q
3. 谨慎使用压缩这个是出于保留动态的角度考虑的。如果某个乐器的动态本来就过大，最好还是适当进行压缩。通常我会把鼓之类的压一压让声音更结实，人声当然也要压过，别的乐器就不怎么上压缩了。一些pluck可能会考虑加一个适度的压缩器提升一下rms，其实意义不大。总的来说如果峰值有点高，把推子往下推可能是一个更好的选择。
4. 全局混响能用全局混响尽量还是用全局吧，这样可以让整体的混响统一和谐。一般情况下全局混响的声音出来是比单独设置混响好听的。当然一些特殊情况（比如利用混响制造特殊效果）除外。如果因为各种原因无法使用全局混响，不妨将混响也视为一种特殊的乐器加入混音。Fruit自带的Reeverb2挺好用的。
5. 充分利用插件内建的效果器插件之所以自带这么多效果器，有一部分原因是这些效果器本身就是适用于这个插件的。换句话说，使用插件自带的效果器可以最高效率地让音色变得更加好听。
6. 效果器的串联顺序很重要这一点其实是基础知识，我拿过来凑数的。大家都知道先压缩后混响和先混响后压缩出来的声音有何不同。当然串联顺序不是死的，完全可以根据需要来调节顺序。关于母带插件的选择，我平时都是用iZotope Ozone 6的，臭氧用的人也挺多的这一点不多说了。偷懒的话会用T-RackS的一个Soft
   Clipper提响度（不是很推荐）。然后这两年响战打的差不多了，其实不少人又开始重新强调动态了，分段压缩模块尽量避免使用太大的压缩比、太小的attack和过大的增益吧。

Maximus

处理前

低沉，沉闷

没有轨道的区别，音乐也没有什么层次，更加没有空间感，总的来说，所有东西堆在一起的感觉。

处理后

总体来说：明亮，干净

在Maximus的初步调节下，每个频段的压缩经过动态处理后，音乐变得更加灵活了。

你需要知道，在一首完整的歌曲中，可以大致分为三个频段：低频 中频 高频。
但在有时候，你很难兼顾到每个频段的压缩，所以，你需要把这三个频段的压缩比调节到一致的水平。
至此，便需要进行独立的频段监控，把相对高的压缩下来，把低的提高上去（或者不提高）

在线播放

我的总结

音乐这个东西，是艺术，是频率交错间的美。

我在这条路上还有很长的距离。

路漫漫其修远兮，吾将上下而求索。

我到了一家公司去实习了，他们做的需求大概就是做土地规划吧，我开始不知道我去能学些什么…

有始有终

ArcGIS是由ESRI出品的一个地理信息系统系列软件的总称。可以依不同应用平台分成以下版本：
桌面版本：以功能等级而区分的套件：ArcReader、ArcView、ArcEditor和ArcInfo，而高级的套件是较低级套件加上其他进阶功能。
服务器版本：以功能等级（基本、标准、进阶）而区分为ArcIMS (web mapping server), ArcGIS Server与ArcGIS Image Server。
移动版：ArcGIS Mobile与ArcPad

当我认为会像学习Photoshop或者Adobe全家桶的时候。基于Python？我的热情一下子就来了，随后我查阅相关资料：

• ArcPy (ArcGIS API for Python)
• ArcGIS API for JavaScript

看到这我一下就明白了

我开始学习ArcPy的标准库使用方法，万事开头难，但还好我有着Python的相关基础
阅读了一下文档就拨云见日了

官网文档

其他请参见：https://www.jianshu.com/p/3355b6efc0d6

安装

在安装ArcGIS的时候，默认会安装Python27版本并安装ArcPy的标准运行库

所以繁琐的东西已经都为我们做好了，在我开始安装的时候，并不知道，我安装了一个Python37，并且手动去配置ArcPy的包

最后：肯定是失败了的，在开始之前，做一些资料功课和准备还是很有必要的

我的第一个需求

我当时所接收到的信息就是上面这些，然后我拿到了一些格式参照，还有一个word文档（里面是具体的格式要求）

内心OS：算了，虽然刚刚开始，但是没有难度就没有进步嘛…

我开始了和这个库的死磕
一堆奇奇怪怪的东西出来了，加载前提是什么？

我在观摩了大佬作品后，发现加载一些文件是无法用游标去处理和迭代了，具体就是这些参数类并没有定义相关方法，这个坑我踩了很久才爬出来。

首先不得不吐槽百度，还有CSDN博客园这类搬运站，还有国内开源社区的混乱。

整理了一些坑

在读取shp文件的时候，会默认需要打开shp所在文件夹下的其他文件（钩子）

网上很多都是错误的，但也有理可循，像添加env.workspace

Python的一些好用的小技巧

不论在处理什么数据的时候，都是以对象的方式进行（把String，Int这些基础整型也理解为对象）
Python对于可迭代对象真的很友好
在处理多重数据的时候，一定要复核一遍有无多状况出现（空？）
我把他丢到了Github仓库：https://github.com/PluginsKers/ArcPy_Scripts

今天过了单元测试了

这也算是一些经验吧。

2021.6.2

又一个新的需求，开始咯~

2021.6.8

圆满结束实习…

其他杂谈

在项目开发的过程中，有一个前辈，他告知每次处理地方信息的时候，都是将一个总excel拆开（当我看到这个excel的时候…..它有10k条数据，按照：村、镇、市。来划分）也就是说，此前一直都是人工手动的分割数据到单个excel中。

我手写了一个简单的脚本，以10s/6k条数据的的速度，将数据分割成单个excel，这样就可以节省大量的时间。

使用Vue.js开发的流式程式。

项目介绍

踩坑记录

Swiper的大坑

Swiper我是真没想到这么大一个锅在你身上

谁知道我卸载安装了多少遍

报错都类似这样：

1 2 3 4 5 6

warning in ./node_modules/_swiper@6.5.0@swiper/esm/vue/swiper.js 638:10-11 "export 'h' was not found in 'vue' warning in ./node_modules/_swiper@6.5.0@swiper/esm/vue/swiper-slide.js 66:13-14 "export 'h' was not found in 'vue' warning in ./node_modules/_swiper@6.5.0@swiper/esm/vue/swiper-slide.js 70:22-23 "export 'h' was not found in 'vue'

尝试过的方案：

更换低版本的Swiper

修改createVue为链式创建

1
2
3
4
5
6
7
8
9

transformRequest: [
  data => {
    let params = '';
    for (var index in data) {
      params += index + '=' + data[index] + '&';
    }
    return params;
  }
]

开发小结

1.0.0

1.0.1

1.0.2

1.0.3

1.0.4

1.0.5Beta

1.0.5

其他

网易云热评墙 这个故事还没有结束！

接口详情

通过UDP协议获取MCPE的服务器状态

请求参数

返回参数

错误码

其他