大语言模型资料汇总

一、之前整理了一些大模型的Demo,汇总如下
1、ChatGPT
https://github.com/neohope/NeoDemosChatGPT

2、Llama2
https://github.com/neohope/NeoDemosLlama2
可同步看一下中文版Llama2
https://github.com/ymcui/Chinese-LLaMA-Alpaca-2

3、阿里千问
https://github.com/neohope/NeoDemosQwen

4、清华ChatGLM
https://github.com/neohope/NeoDemosChatGLM

二、建议看一下llama.cpp
1、llama.cpp
https://github.com/ggerganov/llama.cpp

2、python的llama.cpp封装
https://github.com/abetlen/llama-cpp-python

3、千问的qwen.cpp实现
https://github.com/QwenLM/qwen.cpp

4、ChatGLM的chatglm.cpp实现
https://github.com/li-plus/chatglm.cpp

三、还有量化
https://github.com/AutoGPTQ/AutoGPTQ

四、当然还有langchain
https://github.com/langchain-ai/langchain

五、如果有余力,看一下Transformer实现
https://github.com/huggingface/transformers

llama.cpp简要教程

1、下载并编译llama.cpp

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make

2、下载llama-2-7b-chat
a、可以从fb或hf下载
b、可以使用脚本下载工具,比如llama-dl
c、可以使用Chinese-LLaMA-2-7B
d、可以使用其他三方源

3、模型转换为ggml格式

python3 convert.py ../llama/llama-2-7b-chat/ 
Loading model file ../llama/llama-2-7b-chat/consolidated.00.pth
params = Params(n_vocab=32000, n_embd=4096, n_layer=32, n_ctx=2048, n_ff=11008, n_head=32, n_head_kv=32, n_experts=None, n_experts_used=None, f_norm_eps=1e-06, rope_scaling_type=None, f_rope_freq_base=None, f_rope_scale=None, n_orig_ctx=None, rope_finetuned=None, ftype=None, path_model=PosixPath('../llama/llama-2-7b-chat'))
Found vocab files: {'tokenizer.model': PosixPath('../llama/tokenizer.model'), 'vocab.json': None, 'tokenizer.json': None}
Loading vocab file '../llama/tokenizer.model', type 'spm'
Vocab info: <SentencePieceVocab with 32000 base tokens and 0 added tokens>
Special vocab info: <SpecialVocab with 0 merges, special tokens unset, add special tokens unset>
tok_embeddings.weight                            -> token_embd.weight                        | BF16   | [32000, 4096]
norm.weight                                      -> output_norm.weight                       | BF16   | [4096]
output.weight                                    -> output.weight                            | BF16   | [32000, 4096]
layers.0.attention.wq.weight                     -> blk.0.attn_q.weight                      | BF16   | [4096, 4096]
...
layers.31.ffn_norm.weight                        -> blk.31.ffn_norm.weight                   | BF16   | [4096]
skipping tensor rope_freqs
Writing ../llama/llama-2-7b-chat/ggml-model-f16.gguf, format 1
Ignoring added_tokens.json since model matches vocab size without it.
gguf: This GGUF file is for Little Endian only
[  1/291] Writing tensor token_embd.weight                      | size  32000 x   4096  | type F16  | T+   3
...
[291/291] Writing tensor blk.31.ffn_norm.weight                 | size   4096           | type F32  | T+ 314
Wrote ../llama/llama-2-7b-chat/ggml-model-f16.gguf

4、模型量化,减少资源使用

./quantize ../llama/llama-2-7b-chat/ggml-model-f16.gguf  ../llama/llama-2-7b-chat/ggml-model-f16-q4_0.gguf q4_0 
main: build = 2060 (5ed26e1f)
main: built with cc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0 for x86_64-linux-gnu
main: quantizing '../llama/llama-2-7b-chat/ggml-model-f16.gguf' to '../llama/llama-2-7b-chat/ggml-model-f16-q4_0.gguf' as Q4_0
llama_model_loader: loaded meta data with 15 key-value pairs and 291 tensors from ../llama/llama-2-7b-chat/ggml-model-f16.gguf (version GGUF V3 (latest))
llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output.
llama_model_loader: - kv   0:                       general.architecture str              = llama
llama_model_loader: - kv   1:                               general.name str              = llama
llama_model_loader: - kv   2:                       llama.context_length u32              = 2048
llama_model_loader: - kv   3:                     llama.embedding_length u32              = 4096
llama_model_loader: - kv   4:                          llama.block_count u32              = 32
llama_model_loader: - kv   5:                  llama.feed_forward_length u32              = 11008
llama_model_loader: - kv   6:                 llama.rope.dimension_count u32              = 128
llama_model_loader: - kv   7:                 llama.attention.head_count u32              = 32
llama_model_loader: - kv   8:              llama.attention.head_count_kv u32              = 32
llama_model_loader: - kv   9:     llama.attention.layer_norm_rms_epsilon f32              = 0.000001
llama_model_loader: - kv  10:                          general.file_type u32              = 1
llama_model_loader: - kv  11:                       tokenizer.ggml.model str              = llama
llama_model_loader: - kv  12:                      tokenizer.ggml.tokens arr[str,32000]   = ["<unk>", "<s>", "</s>", "<0x00>", "<...
llama_model_loader: - kv  13:                      tokenizer.ggml.scores arr[f32,32000]   = [0.000000, 0.000000, 0.000000, 0.0000...
llama_model_loader: - kv  14:                  tokenizer.ggml.token_type arr[i32,32000]   = [2, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, ...
llama_model_loader: - type  f32:   65 tensors
llama_model_loader: - type  f16:  226 tensors
llama_model_quantize_internal: meta size = 740928 bytes
[   1/ 291]                    token_embd.weight - [ 4096, 32000,     1,     1], type =    f16, quantizing to q4_0 .. size =   250.00 MiB ->    70.31 MiB | hist: 0.037 0.016 0.025 0.039 0.057 0.077 0.096 0.111 0.116 0.111 0.096 0.077 0.057 0.039 0.025 0.021 
...   
[ 291/ 291]               blk.31.ffn_norm.weight - [ 4096,     1,     1,     1], type =    f32, size =    0.016 MB
llama_model_quantize_internal: model size  = 12853.02 MB
llama_model_quantize_internal: quant size  =  3647.87 MB
llama_model_quantize_internal: hist: 0.036 0.015 0.025 0.039 0.056 0.076 0.096 0.112 0.118 0.112 0.096 0.077 0.056 0.039 0.025 0.021 
main: quantize time = 323302.84 ms
main:    total time = 323302.84 ms

5、使用模型

./main -m ../llama/llama-2-7b-chat/ggml-model-f16-q4_0.gguf -n 256 --repeat_penalty 1.0 --color -ins

使用ChatGPT翻译了几本书

在2014年左右,一直想翻译几本小册子(主要是介绍编的程经验教训,内容其实很老了,但当时有些内容确实触动了我),陆陆续续翻译了其中的一些文章,但各种原因还是没能翻译完毕,算是一个小遗憾。

最近用ChatGPT硬翻了一遍,感觉效果还可以,感兴趣的朋友可以随便翻翻。

架构师应该知道的97件事【ChatGPT翻译版本,52篇】
https://github.com/neohope/97-things-every-software-architect-should-know.git

敏捷程序员应该知道的97件事【ChatGPT翻译版本,26篇】
https://github.com/neohope/97-things-every-agile-developer-should-know.git

程序员应该知道的97件事【ChatGPT翻译版本,97篇】
https://github.com/neohope/97-things-every-programmer-should-know.git

对比了一下自己翻译的版本:
1、最大的感触之一是质量的提升,比Goolge、NewBing翻译的都要好很多,十年前的翻译效果更是没法比
2、最大的感触之二是效率,175篇文章,加上编程、翻译及校对的时间,花了不到10小时(很多是零散时间),平均一篇文章3分半不到,比之前人工+Google的速度快了不止10倍
3、有些文章质量仍有待提升

还有一些感触:
1、虽然有些文章质量有待提升,但非专业领域翻译相关工作被替代可能性十分高大概率会被迫转型,专业领域翻译相关工作效率也会大幅增加大概率不需要这么多人力了
2、后续互联网客服、视频脚本编写、字幕翻译、新闻稿编写、文章编纂、律师助理等文字相关工作人员,会逐步面临更大职业压力
3、建议早点学会用AI提升个人生产力,淘汰不会用AI的人

谈谈ChatGPT

春节期间,试用了ChatGPT,让我被惊艳到了。
大模型的涌现效果,能达到ChatGPT3.5的程度,着实让我有些吃惊,真是大力出奇迹啊。

在此之前,我一直认为本次AI技术革命已经接近尾声了:
1、在影像和视频方面,AI已经可以实现商业化:医疗影像AI诊断、自动驾驶、人脸识别、图像搜索、P图滤镜等;
2、在语音方面,语音识别和语音合成已经很成熟;
3、在NLP方面,简单重复任务可以较好完成,比如机器翻译、文本搜索等。但在复杂任务上,还处于有多少人工就有多少智能的尴尬阶段,距离商业化有较长的路需要走;
而且,无论是哪个领域,大家可以发现,AI还是只是一种能力、一个工具,也就是处于“业务X+AI”的模式。
就算AI是生产力,但想象空间也就那么大,因为领域已经被限制死了。

但ChatGPT改变了这个局面,聊天这个场景,可以让ChatGPT成为一个各种能力的插座。
也就是说,一个类似于ChatGPT的大模型,如果能快速整合各种外部能力,从“业务X+AI”,变成“AI+业务X、业务Y、业务Z”的模式,很可能会成为下一代互联网的入口,并从各种维度给人类带来全新体验。

钢铁侠的贾维斯(J.A.R.V.I.S.)还是保守了,我们有更广阔的空间,十分期待这个时代能尽快到来。

同时,国内大厂的大模型层出不穷,究竟谁能成功,还要看三个地方:
1、要有足够大量的数据
2、要有AI人才储备
3、要有足够算力,如果现在才去买显卡,就很难赶上了
国内满足这几点的有:质谱【从闭源到开源】、阿里【闭源到开源】、百度【已掉队】、字节【已掉队】

最近看了一些ChatGPT资料,整理了一些相关示例:
https://github.com/neohope/NeoDemosChatGPT

其中多数例子,来源于极客时间徐文浩老师的课程《AI大模型之美》:
https://time.geekbang.org/column/intro/100541001?tab=catalog

================
补充0812:
当前国内大模型厂商,在底层方面依赖英伟达,在模型技术层面无法相互拉开差距,只能继续向上做:
1、在基础模型层面,支持各类开源模型,弥补自家模型缺点
2、在行业领域,开展合作,把垂直领域模型吃掉
3、在应用层面,也开始逐步布局
加上外资撤出,投资方的钱更难拿,围剿之下,AI方向国内的创业氛围就比较差了。

Transformer03:自注意力机制

Transformer模型的核心是自注意力机制(Self-Attention),它允许模型在处理序列时,能够捕捉序列内部不同位置之间的依赖关系。自注意力机制的计算过程可以概括为以下几个步骤:

1. 查询(Query)、键(Key)、值(Value)的生成:
对于输入序列中的每个元素,模型会分别生成对应的查询(Q)、键(K)和值(V)。这通常是通过输入序列与三个不同的权重矩阵相乘来实现的。

2. 注意力分数的计算:
对于序列中的每个元素,计算其查询(Q)与序列中所有元素的键(K)的点积,然后除以一个缩放因子(通常是键向量维度的平方根),得到一个注意力分数。

   
  \[
   \text{Attention Score} = \frac{Q \cdot K^T}{\sqrt{d_k}}
   \]

其中,(Q)和(K)分别是查询和键的向量,\(d_k\) 是键向量的维度。

3. Softmax归一化:
使用Softmax函数对注意力分数进行归一化处理,使得所有元素的注意力分数之和为1。这表示每个元素对其他元素的注意力贡献是相对的。

   
   \[
   \text{Attention Weights} = \text{Softmax}(\text{Attention Score})
   \]

4. 加权求和:
将归一化后的注意力权重与对应的值(V)相乘,然后将所有元素的加权值相加,得到最终的输出。

   
   \[
   \text{Output} = \sum (\text{Attention Weights} \times V)
   \]

5. 多头注意力:
Transformer模型中的自注意力通常不是只计算一次,而是通过多头注意力(Multi-Head Attention)来实现。这意味着模型会并行地执行多次自注意力机制,每个头都有自己的查询、键和值权重矩阵。最后,这些头的输出会被拼接起来,并通过一个线性层来整合信息。

6. 残差连接和层归一化:
在自注意力层之后,通常会有一个残差连接,它将自注意力层的输入直接添加到输出上,然后通过一个层归一化(Layer Normalization)来稳定训练过程。

整个自注意力机制使得Transformer能够并行处理序列中的所有元素,并且能够捕捉到元素之间的长距离依赖关系,这是它在处理序列数据时非常有效的原因之一。

让我们通过一个简单的例子来说明自注意力机制的计算过程。假设我们有一个由3个词组成的序列:[“I”, “love”, “coding”],并且每个词的词嵌入维度是4。

步骤1: 词嵌入
首先,我们将每个词转换为词嵌入向量。假设词嵌入矩阵已经预先训练好,我们可以直接获取每个词的词嵌入向量:

– “I” -> [0.1, 0.2, 0.3, 0.4]
– “love” -> [0.5, 0.6, 0.7, 0.8]
– “coding” -> [0.9, 1.0, 1.1, 1.2]

步骤2: 添加位置编码
接下来,我们为每个词嵌入向量添加位置编码。假设我们使用标准的正弦和余弦函数生成位置编码,并且序列的最大长度是3。位置编码向量如下:

– 位置1的编码:[sin(0), cos(0), sin(8), cos(8)] (这里8是4*2,因为每个词嵌入维度是4)
– 位置2的编码:[sin(1), cos(1), sin(9), cos(9)]
– 位置3的编码:[sin(2), cos(2), sin(10), cos(10)]

将位置编码向量与词嵌入向量相加:

– “I” (位置1): [0.1+sin(0), 0.2+cos(0), 0.3+sin(8), 0.4+cos(8)]
– “love” (位置2): [0.5+sin(1), 0.6+cos(1), 0.7+sin(9), 0.8+cos(9)]
– “coding” (位置3): [0.9+sin(2), 1.0+cos(2), 1.1+sin(10), 1.2+cos(10)]

步骤3: 自注意力计算
现在我们开始自注意力的计算过程。首先,我们需要为每个词生成查询(Q)、键(K)和值(V)向量。假设我们使用相同的词嵌入向量作为Q、K和V的初始输入,并通过不同的权重矩阵进行转换:

– Q = W^Q * 输入向量
– K = W^K * 输入向量
– V = W^V * 输入向量

这里W^Q、W^K和W^V是模型的可学习参数。

步骤4: 计算注意力分数
对于序列中的每个词,我们计算其查询向量与序列中所有词的键向量的点积,然后除以键向量维度的平方根进行缩放:

– 对于词”I”,其注意力分数是它自己的Q与所有词的K的点积:

   
  \[
  \text{Attention Score}_{I \rightarrow \text{all}} = \frac{Q_I \cdot (K_{I} + K_{love} + K_{coding})^T}{\sqrt{d_k}}
  \]

步骤5: Softmax归一化
使用Softmax函数对每个词的注意力分数进行归一化处理:

– 对于词”I”,归一化后的注意力权重是:

   
  \[
  \text{Attention Weights}_{I \rightarrow \text{all}} = \text{Softmax}(\text{Attention Score}_{I \rightarrow \text{all}})
  \]

步骤6: 加权求和
最后,将归一化后的注意力权重与对应的值向量相乘,并求和得到最终的输出:

– 对于词”I”,其输出是:

   
  \[
  \text{Output}_I = \text{Attention Weights}_{I \rightarrow I} \cdot V_I + \text{Attention Weights}_{I \rightarrow love} \cdot V_{love} + \text{Attention Weights}_{I \rightarrow coding} \cdot V_{coding}
  \]

这个过程对于序列中的每个词都要重复执行,以计算整个序列的输出。自注意力机制允许模型在处理每个词时,都能够考虑到序列中其他所有词的信息,从而捕捉词与词之间的复杂关系。

请注意,这个例子是一个简化的版本,实际的Transformer模型可能会使用多头自注意力机制,并且会有多个层来进一步处理信息。此外,词嵌入和位置编码通常是通过预训练得到的,而不是从头开始训练。

Transformer02:词嵌入及位置编码的计算

一句话经过分词和嵌入之后,输入到Transformer模型的过程如下:

1. 构建输入序列:
将分词后得到的词或字符序列转换为对应的词嵌入向量。每个词或字符都有一个对应的嵌入向量,这些向量通常通过预训练的词嵌入模型获得。

2. 添加位置编码:
由于Transformer模型本身不包含递归或卷积结构,因此它无法直接捕捉序列中的位置信息。为了解决这个问题,需要为每个词嵌入向量添加一个位置编码。位置编码通常是根据词在序列中的位置生成的,它与词嵌入向量相加,使得模型能够利用位置信息。

3. 输入到Transformer:
将包含位置编码的词嵌入向量作为输入序列送入Transformer模型。在Transformer模型中,输入序列被处理为一系列向量,每个向量对应序列中的一个元素(词或字符)。

4. 多头自注意力:
Transformer模型使用多头自注意力机制来处理输入序列。在自注意力层中,每个元素的嵌入向量都会与序列中所有其他元素的嵌入向量进行比较,以计算注意力权重。这个过程在多个“头”中并行进行,每个头都有自己的查询(Q)、键(K)和值(V)权重矩阵。

5. 层归一化和前馈网络:
自注意力层的输出会经过层归一化,然后送入前馈神经网络。前馈网络通常由两个线性变换和一个非线性激活函数组成。这个过程在每个Transformer层中重复进行。

6. 堆叠多个Transformer层:
Transformer模型通常由多个相同的层堆叠而成,每个层都包含自注意力机制和前馈网络。通过这种方式,模型可以在不同层捕捉不同级别的特征和依赖关系。

7. 输出处理:
经过多个Transformer层处理后,模型的输出可以用于各种NLP任务,如语言翻译、文本摘要、问答等。对于特定的任务,可能还需要在Transformer模型的顶部添加额外的层,如线性层或分类层。

总之,每个嵌入向量并不是有自己的Transformer,而是所有嵌入向量一起作为输入序列,被送入同一个Transformer模型中进行处理。通过多头自注意力机制,模型能够捕捉序列内部不同位置之间的依赖关系,从而实现对输入句子的深入理解。

通过一个简单的例子来说明词嵌入和位置编码的计算过程。

### 词嵌入(Word Embedding)

假设我们有一个句子:”I love natural language processing”。首先,我们需要将这个句子分词成单词列表:[“I”, “love”, “natural”, “language”, “processing”]。

接下来,每个单词将通过一个词嵌入矩阵转换成一个固定维度的向量。假设我们的词嵌入维度是4,那么每个单词将被映射到一个4维空间中。例如:

– “I” -> [0.1, 0.2, 0.3, 0.4]
– “love” -> [0.5, 0.6, 0.7, 0.8]
– “natural” -> [0.9, 1.0, 1.1, 1.2]
– “language” -> [1.3, 1.4, 1.5, 1.6]
– “processing” -> [1.7, 1.8, 1.9, 2.0]

这里的数字是随机生成的,实际的词嵌入向量是通过训练得到的,能够捕捉单词的语义信息。

### 位置编码(Positional Encoding)

Transformer模型不包含递归或卷积结构,因此无法直接捕捉序列中单词的顺序信息。为了解决这个问题,我们需要为每个词嵌入向量添加位置编码。

位置编码通常是通过正弦和余弦函数的组合来生成的,以确保不同维度的位置编码具有不同的频率。假设我们的词嵌入维度是4,我们可以为每个位置生成一个4维的位置编码向量:

– 位置1的编码:[sin(1/10000), cos(1/10000), sin(2/10000), cos(2/10000)]
– 位置2的编码:[sin(2/10000), cos(2/10000), sin(4/10000), cos(4/10000)]
– 以此类推…

将位置编码向量与相应的词嵌入向量相加,得到最终的输入向量:

– “I” (位置1): [0.1+sin(1/10000), 0.2+cos(1/10000), 0.3+sin(2/10000), 0.4+cos(2/10000)]
– “love” (位置2): [0.5+sin(2/10000), 0.6+cos(2/10000), 0.7+sin(4/10000), 0.8+cos(4/10000)]
– 以此类推…

这样,每个单词的嵌入向量都包含了其在句子中的位置信息,使得Transformer模型能够在处理序列时考虑到单词的顺序。

### 注意事项

– 词嵌入和位置编码的具体计算方法可能因不同的模型和实现而有所不同。
– 实际应用中,词嵌入通常是通过预训练模型(如Word2Vec、GloVe或BERT)得到的,而不是从头开始训练。
– 位置编码的生成方法在不同的Transformer变体中可能有所不同,例如Transformer-XL和XLNet采用了不同的方法来处理长序列。

这个例子展示了词嵌入和位置编码的基本计算过程,以及它们如何帮助Transformer模型理解和处理自然语言序列。

在实际应用中,词嵌入和位置编码可以预先计算并缓存,以提高效率。下面是一些具体的情况:

1. 词嵌入的缓存:
– 词嵌入通常是通过预训练语言模型得到的,这些模型在大规模语料库上训练,学习到的词嵌入向量能够捕捉丰富的语义信息。
– 一旦词嵌入矩阵训练完成,对于任何给定的单词,其对应的词嵌入向量就可以直接从预训练的模型中获取,而不需要每次重新计算。

2. 位置编码的缓存:
– 位置编码的生成方式是固定的,例如使用正弦和余弦函数的组合,这意味着对于给定的维度和最大序列长度,位置编码向量可以预先计算出来。
– 在模型初始化阶段,可以生成一个位置编码矩阵,其中每一行对应一个位置的位置编码。在处理输入序列时,只需根据序列中单词的位置索引来选择相应的位置编码向量。

3. 缓存的优势:
– 缓存词嵌入和位置编码可以显著减少模型在每次前向传播时的计算量,特别是对于大型模型和长序列。
– 缓存还可以减少模型的延迟,因为从内存中读取预先计算好的向量比实时计算要快得多。

4. 实际应用:
– 在实际的深度学习框架中,如TensorFlow或PyTorch,词嵌入和位置编码通常作为模型的参数或静态变量存储,以便在模型训练和推理过程中重复使用。

5. 灵活性:
– 虽然位置编码通常是固定的,但在某些情况下,如果模型需要处理可变长度的序列,位置编码也可以动态生成。但即使如此,对于常见的序列长度,位置编码的计算可以预先完成,并存储在查找表中以供快速访问。

通过这种方式,词嵌入和位置编码的预先计算和缓存,可以使得Transformer模型更加高效地处理输入数据,特别是在处理大量数据或需要快速响应的应用场景中。

Transformer01:总论

在处理自然语言处理(NLP)任务时,输入一句话通常需要经过以下步骤:

1. 分词(Tokenization):
首先,输入的句子需要被分词,即将句子拆分成更小的单元,这些单元可以是单词、字符或者其他语言单位。分词是处理自然语言的第一步,因为大多数模型都是基于离散的词或字符进行操作的。

2. 词嵌入(Embedding):
分词之后,每个词或字符会被转换成词嵌入(Word Embedding)。词嵌入是将离散的词或字符映射到连续的向量空间中的一种表示方法。这些向量能够捕捉词的语义信息,并且通常通过预训练模型(如Word2Vec、GloVe或BERT等)来获得。

3. 位置编码(Positional Encoding):
对于Transformer模型,由于其自注意力机制无法捕捉序列中元素的顺序信息,因此需要添加位置编码。位置编码是一种向量,它与词嵌入相加,以提供序列中每个元素的位置信息。

4. 序列化(序列化处理):
在某些情况下,如果输入序列超过了模型的最大长度限制,可能还需要进行序列化处理,如截断或填充。

5. 模型处理:
经过上述步骤处理后,得到的序列化、嵌入化和编码后的输入数据就可以被送入模型进行进一步的处理和学习了。

因此,当输入一句话时,通常是先进行分词,然后计算词嵌入,最后将分词后的词嵌入与位置编码相结合,形成模型的输入。这个过程使得模型能够理解句子的结构和语义信息,并在此基础上进行各种NLP任务。

TensorFlow入门02:Tensor

Tensorflow中所有的数据都称为Tensor,可以是一个变量、数组或者多维数组。Tensor 有几个重要的属性:
Rank:纬数,比如scalar rank=0, vector rank=1, matrix rank=2
Shape:形状,比如vector shape=[D0], matrix shape=[D0, D1]
类型:数据类型,比如tf.float32, tc.uint8等

Rank与Shape关系如下表所示

Rank Shape Dimension number Example
0 [] 0-D A 0-D tensor. A scalar.
1 [D0] 1-D A 1-D tensor with shape [5].
2 [D0, D1] 2-D A 2-D tensor with shape [3, 4].
3 [D0, D1, D2] 3-D A 3-D tensor with shape [1, 4, 3].
n [D0, D1, … Dn-1] n-D A tensor with shape [D0, D1, … Dn-1].

TensorFlow入门01:环境搭建

1、CPU版本安装

1.1 安装tensorflow

pip3 install --upgrade tensorflow

1.2 Python验证,看到版本信息就可以了

python3
>>> import tensorflow as tf
>>> print('Tensorflow version ', tf.__version__)

Tensorflow version  1.12.0

2、GPU版本安装(需要NVIDIA显卡)

2.1 检查驱动信息

nvidia-smi

Fri Nov 16 21:22:13 2018
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 390.77                 Driver Version: 390.77                    |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 106...  Off  | 00000000:01:00.0 Off |                  N/A |
| N/A   52C    P2    27W /  N/A |   5938MiB /  6078MiB |     22%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|    0      7953      G   /usr/lib/xorg/Xorg                           126MiB |
|    0      8215      G   /usr/bin/gnome-shell                         109MiB |
|    0     13578    C+G   python3                                     5689MiB |
+-----------------------------------------------------------------------------+

2.2 安装CUDA

# 查看网站 https://developer.nvidia.com/cuda-90-download-archive?target_os=Linux&target_arch=x86_64&target_distro=Ubuntu&target_version=1704&target_type=runfilelocal
# 选择下载这个版本 Linux x86_64 Ubuntu 17.04 runfile
# 安装,但注意不要更新驱动
sudo chmod +x cuda_9.0.176_384.81_linux.run
./cuda_9.0.176_384.81_linux.run --override

2.3 安装CUDNN

# 查看网站 https://developer.nvidia.com/rdp/cudnn-download
# 选择下载这个版本 9.0 cuDNN Library for Linux
# 解压
tar -zxvf cudnn-9.0-linux-x64-v7.tgz
# 手工安装
sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda-9.0/lib64/
sudo cp  cuda/include/cudnn.h /usr/local/cuda-9.0/include/
# 调整权限
sudo chmod a+r /usr/local/cuda-9.0/include/cudnn.h /usr/local/cuda-9.0/lib64/libcudnn*

2.3 安装libcupti-dev

sudo apt-get install libcupti-dev

2.4 修改.bashrc

# 增加下面两行
export PATH=/usr/local/cuda-9.0/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

2.5 安装tensorflow-gpu

pip3 install --upgrade tensorflow-gpu

2.6 Python验证,看到GPU就可以啦

Python3
>>> from tensorflow.python.client import device_lib
>>> device_lib.list_local_devices()

[name: "/device:CPU:0"
device_type: "CPU"
memory_limit: 268435456
locality {
}
...
incarnation: 2559160109308400478
physical_device_desc: "device: 0, name: GeForce GTX 1060 with Max-Q Design, pci bus id: 0000:01:00.0, compute capability: 6.1"
]

3、Docker方式安装
3.1 CPU版

# 运行tensorflow
docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow

3.2 GPU版

# 安装nvidia-docker
wget https://github.com/NVIDIA/nvidia-docker/releases/download/v1.0.1/nvidia-docker_1.0.1-1_amd64.deb
sudo dpkg -i nvidia-docker*.deb

# 测试nvidia-docker,执行nvidia-smi命令
nvidia-docker run --rm nvidia/cuda nvidia-smi

# 运行tensorflow
nvidia-docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow:latest-gpu

4、编译CUDA Demo(非必须)

# 咱们选用的版本只支持到gcc6
apt-get install gcc-6 g++-6
ln -s /bin/gcc /bin/gcc-6

# 安装libmpich-dev
sudo apt-get install libmpich-dev


# 切换路径
cd PATH_TO_DEMO

# 编译
make

知识图谱03:JENA

1、下载apache-jena-fuseki和apache-jena
https://jena.apache.org/download/index.cgi

2、将上一篇教程的nt文件转换为tdb格式

cd apache-jena-3.9.0\bat
tdbloader.bat --loc="PATH_TO_TDB\tdb" "PATH_TO_NT\movies_mapping.nt"

3、切换到apache-jena-fuseki-3.9.0目录,启动一次服务,然后退出

4、将教程1里面的Movies.owl,拷贝到apache-jena-fuseki-3.9.0\run\databases路径下面,并重命名为Movies.ttl

5、创建配置文件apache-jena-fuseki-3.9.0\run\configuration\fuseki_conf.ttl

@prefix fuseki: <http://jena.apache.org/fuseki#> . 
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . 
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . 
@prefix tdb: <http://jena.hpl.hp.com/2008/tdb#> . 
@prefix ja: <http://jena.hpl.hp.com/2005/11/Assembler#> . 
@prefix : <http://base/#> . 

<#service> rdf:type fuseki:Service ; 
    fuseki:name "movies" ;
    fuseki:serviceQuery "sparql" ;
    fuseki:dataset <#dataset> ; 
    fuseki:serviceReadGraphStore      "get" ;
    fuseki:serviceReadWriteGraphStore "data" ;
    fuseki:serviceUpdate              "update" ;
    fuseki:serviceUpload              "upload"
    . 

<#dataset> rdf:type ja:RDFDataset ;
	ja:defaultGraph <#modelInf> ;
	.

<#modelInf> 
    rdf:type ja:InfModel ;
    #ja:reasoner [ja:reasonerURL <http://jena.hpl.hp.com/2003/OWLFBRuleReasoner>]  
    ja:reasoner [ 
        ja:reasonerURL <http://jena.hpl.hp.com/2003/GenericRuleReasoner> ; 
        ja:rulesFrom <file:///D:/ProjectsMy/KG/apache-jena-fuseki-3.9.0/run/databases/Rules.ttl> ] ; 
    ja:baseModel <#baseModel> ; 
    . 

<#baseModel> rdf:type tdb:GraphTDB ; 
    tdb:location "D:/ProjectsMy/KG/workspace/data/tdb" ; 
    tdb:unionDefaultGraph true ; 
    .

6、创建规则文件apache-jena-fuseki-3.9.0\run\databases\Movies.ttl
这个规则规定了,演过喜剧的演员,叫做喜剧演员(Comedian)

@prefix xsd: <XML Schema> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix : <https://www.neohope.com/hansen/ontologies/2018/movies#> .

[ruleComedian: (?aPerson :hasActedIn ?aMovie) (?aMovie :hasGenre ?aGenre) (?aGenre :genreName '喜剧') -> (?aPerson rdf:type :Comedian)]
[ruleInverse: (?aPerson :hasActedIn ?aMove) -> (?aMovie :hasActor ?aPerson)]

7、启动apache-jena-fuseki-3.9.0

8、访问http://localhost:3030/

9、进行查询,上一篇的例子也都可以用
http://localhost:3030/dataset.html?tab=query&ds=/movies

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
prefix owl: <http://www.w3.org/2002/07/owl#>
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
prefix : <https://www.neohope.com/hansen/ontologies/2018/movies#>

SELECT ?name WHERE {
?aComedian rdf:type :Comedian.
?aComedian :personName ?name.
}
LIMIT 10

10、通过python访问
https://github.com/neohope/kg-demo-for-movie/tree/master/src/query-jena.py

参考链接:
https://zhuanlan.zhihu.com/knowledgegraph
https://github.com/SimmerChan/KG-demo-for-movie

PS:
参考教程中,原作者通过结巴分词+正则匹配+Jena,实现了一个简单的问答系统,感兴趣的话,大家可以看下。