MLTalks

ViT(Vision Transformer)论文阅读

发表于 2023-06-14 分类于机器学习本文字数： 769 阅读时长 ≈ 3 分钟

1. ViT简介

ViT是2020年的一篇paper，目前(2023年2月)在google引用超11000次，CV图像领域中被广泛使用。在ViT出来之前，Transformer架构已经在NLP领域大显身手，在CV领域还是用的CNN，通过ViT这篇paper在CV中正式引入Transormer，且效果不错。

阅读全文 »

pytorch分布式训练使用Dataloader/WebDataset进行数据并行加载

发表于 2023-06-12 分类于机器学习本文字数： 1k 阅读时长 ≈ 4 分钟

1. 使用pytorch原生的DistributedSampler

在pytorch DDP数据并行时会对数据集进行切分，每个rank节点只处理部分数据。使用DistributedSampler来会把dataset数据集采样为一个子数据集。定义如下：

1	torch.utils.data.distributed.DistributedSampler(dataset, num_replicas=None, rank=None, shuffle=True, seed=0, drop_last=False)

dataset：用于采样的数据集
num_replicas (int, optional)：分布式训练总的进程数。默认对应取process_group中的world_size
rank (int, optional)：当前进程的rank号。默认对应取process_group中的rank
shuffle (bool, optional) ：为True表示对indices进行随机打乱。注意使用DistributedSampler时，torch.util.data.Dataloader创建时的shuffle参数，相当于把随机的功能交给了DistributedSampler。默认为True
seed (int, optional)：随机种子，默认为0
drop_last (bool, optional): 为True的话会丢弃结尾的数据，保证数据大小可以被num_replicas整除；为False的话Sampler为增加额外的indices；默认为False

阅读全文 »

Rotary Position Embeddings论文阅读

发表于 2023-06-08 分类于机器学习本文字数： 627 阅读时长 ≈ 2 分钟

1. 论文

1.1 Transformer中的position embedding

Transformer中模型不涉及RNN的循环和CNN的卷积，为了学习到sequence中的前后顺序关系，增加了position embedding, embedding的方法采用了sinine和cosine来进行。

示例如下, 对I am a robot进行编码：

编码过程中d_model=4, 论文中的10000对应改为100，结果如下：

阅读全文 »

RMSNorm论文阅读

发表于 2023-06-07 分类于机器学习本文字数： 714 阅读时长 ≈ 3 分钟

1. 论文

1.1 RMSNorm介绍

RMSNorm论文中对LayerNorm的公式做了改造。在原有LayerNorm中借助了每个layer统计的mean和variance对参数进行了调整，但RMSNorm认为re-centering invariance property是不必要的，只用保留re-scaling invariance property。

LayerNorm的计算如下：

改造后的RMSNorm如下： RMS中去除了mean的统计值的使用，只使用root mean square(RMS)进行归一化。

阅读全文 »

SwiGLU论文阅读

发表于 2023-06-07 分类于机器学习本文字数： 643 阅读时长 ≈ 2 分钟

1. 论文

1.1 背景知识

SwiGLU是2019年提出的新的激活函数，它结合了SWISH和GLU两种者的特点。

1.1.1 SWISH: A SELF-GATED ACTIVATION FUNCTION

SWISH激活函数的定义如下，其中σ(x)是sigmoid函数(如下定义也称为SILU激活) > f(x) = x · σ(x) > σ(x) = (1 + exp(−x))^(-1)

阅读全文 »

LLaMA(Large Language Model Meta AI)论文阅读

发表于 2023-06-06 分类于机器学习本文字数： 957 阅读时长 ≈ 3 分钟

0. 简介

LLaMA 训练了从7B到65B不同参数量的模型，从Hoffmann的论文【Training compute-optimal large languag】中证明了在有限计算代价的情况下(给定总的FLOPs大小)，表现最好的不是参数量最大的模型，而是在更多数据上训练的稍小的模型。

LLaMA实现了两个目标： 1. LLaMA-13B跟GPT-3相比, 参数量小了10倍，但效果更好；LLaMA-65B比Chinchilla-70B和PaLM-540B更好。 2. 只依赖公开的开源数据集也可以达到最好的SOTA效果。

阅读全文 »

SentencePiece论文阅读

发表于 2023-06-06 分类于机器学习本文字数： 532 阅读时长 ≈ 2 分钟

1. 论文

1.1 基本使用

SentencePiece是用于NLP训练中对句子进行token化的工具，跟语言无关, SentencePiece中包含了byte-pairencoding（BPE）和unigram language model两种切分subword的算法。
SentencePiece中包含有四个部分：
- Normalizer: 规一化操作，类似Unicode把字符转为统一格式。
- Trainer: 从规一化后的语料中学习subword的切分模型。
- Encoder: 对应预处理时的tokenization操作，把句子转为对应的subword或id。
- Decoder: 对应后处理时的detokenization操作，把subword或id还原为原有句子

阅读全文 »

对于协程(coroutine)，你必须知道事情都在这里了（内附代码）

发表于 2020-03-29 分类于其他本文字数： 1.6k 阅读时长 ≈ 6 分钟

什么是协程

协程(coroutine) 的概念根据Donald Knuth的说法早在1958年就由Melvin Conway提出了，对应wikipedia的定义如下： > Coroutines are computer program components that generalize subroutines for non-preemptive multitasking, by allowing execution to be suspended and resumed. Coroutines are well-suited for implementing familiar program components such as cooperative tasks, exceptions, event loops, iterators, infinite lists and pipes. 这里_子例程(subroutine)是一个概括性的术语，子例程可以是整个程序中的一个代码区块，当它被主程序调用的时候就会进入运行。例如函数就是子例程中的一种。

1	c = max(a,b);

从wikipedia定义可以看出协程相比子例程更加的灵活，允许执行过程中_被挂起_和_恢复，多个协程可以一起相互协作执行任务。从协程(co + routine)名字上来拆解为支持 协作(cooperate) 的例程。

协程与子例程的执行区别

图中左边是子例程的执行过程，右边是协程的执行过程，可以很明显的看出来执行过程中的区别。 * 先说左边，子例程可以看成是某个函数，子例程的执行过程中通常是嵌套顺序执行的过程，子例程1和子例程2的关系(调用和被调用)不是完全平等的，子例程1能调用子例程2，但子例程2不能反过来调用子例程1。 * 再说右边，协程1和协程2的关系是完全对等的，协程1执行过程中可以中断挂起执行另外一个协程2，反之也是可以的，直到最终两个协程都执行完以后再返回回到主程序中，即协程1和协程2相互协作完成了整个任务。接下来举一个协程实现生产者和消费者的例子：

var q := new queue

coroutine produce
    loop
        while q is not full
            create some new items
            add the items to q
        yield to consume

coroutine consume
    loop
        while q is not empty
            remove some items from q
            use the items
        yield to produce

这里有一个队列queue，一个生产者produce，一个消费者consume，yield代表中断挂起当前协程，并恢复其他协程的操作。生产者生产物品以后加入到队列以后，中断挂起自身并恢复消费者，消费者从队列中消费完物品以后中断挂起自身并恢复生产者，不断来回切换直到达到最终条件（比如所有原料都生产成物品并全都被消费完成），程序终止。

进程、线程、协程的关系和比较

通常会提到 进程是资源分配的最小单位，线程是CPU调度的最小单位, 一个进程里可以有多个线程 ，这里直接画了个图来说明三者关系。

进程是资源分配的最小单位，会拥有独立的地址空间以及对应的内存空间，还有网络和文件资源等，不同进程之间资源都是独立的，可以通过进程间通信（管道、共享内存、信号量等方式）来进行交互。
线程为CPU调度的基本单位，除了拥有运行中必不可少的信息(如程序计数器、一组寄存器和栈)以外，本身并不拥有系统资源，所有线程会共享进程的资源，比如会共享堆资源。
协程可以认为是运行在线程上的代码块，协程提供的挂起操作会使协程暂停执行，而不会导致线程阻塞。一个线程内部可以创建几千个协程都没有任何问题。
进程的切换和线程切换中都包含了对应上下文的切换，这块都涉及到了内核来完成，即一次用户态到内核态的切换和一次内核态到用户态的切换。因为进程上下文切换保存的信息更多，所以进程切换代价会比线程切换代价更大。
协程是一个纯用户态的并发机制，同一时刻只会有一个协程在运行，其他协程挂起等待；不同协程之间的切换不涉及内核，只用在用户态切换即可，所以切换代价更小，更轻量级，适合IO密集型的场景。

coroutine的python实现

Python最初的版本里是包含了yield/send关键字，通过yield/send可以方便的实现一个协程的例子，这里还是以为生产者和消费者为例，具体实现方式如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

def consumer():
    """consumer定义"""
    ret = ''
    while True:
        # 挂起consumer，恢复producer, ret会传回给producer
        item_id = yield ret
        if not item_id:
            return
        print('consume item_id:{}'.format(item_id))
        ret = 'success'

def producer(consumer):
    """producer定义"""
    # send一个None可以看成是启动consumer
    # consumer这里包含了yield关键字相当于是一个generator
    consumer.send(None)
    item_id = 0
    # 生产的item的总数
    item_total_count = 3
    while item_id < item_total_count:
        item_id = item_id + 1
        print('produce item:{}'.format(item_id))
        # 挂起producer，恢复consumer, item_id会传回给consumer
        ret = c.send(item_id)
        print('consumer return:{}'.format(ret))
    consumer.close()

if __name__ == "__main__":
    c = consumer()
    producer(c)

结果：

produce item:1
consume item_id:1
consumer return:success
produce item:2
consume item_id:2
consumer return:success
produce item:3
consume item_id:3
consumer return:success

python 3.5版本开始引入了async/await关键字给了我们另外一种实现的方法，还是以为生产者和消费者为例，具体实现方式如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import asyncio
import random

async def producer(queue, item_total_count):
	"""producer 定义"""
	for item_id in range(0, item_total_count):
    	# 生产一个新的item
    	print('produce item_id:{}'.format(item_id))
    	# 模拟IO操作, 挂起producer，恢复consumer
    	#await asyncio.sleep(random.random())
    	# 把item放入队列, 挂起producer，恢复consumer
    	await queue.put(item_id)
	# 放入一个None到队列表示生产全部结束
	await queue.put(None)


async def consumer(queue):
	"""consumer 定义"""
	while True:
    	# 等待从队列中获得一个新的item, 等待过程中会挂起consumer，恢复producer
    	item_id = await queue.get()
    	if item_id is None:
        	# 表示生产者都生产完了，没有待消费的请求了
        	break
    	print('consume item_id:{}'.format(item_id))
    	# 模拟IO操作, 挂起consumer，恢复producer
    	#await asyncio.sleep(random.random())

if __name__ == "__main__":
	loop = asyncio.get_event_loop()
	queue = asyncio.Queue(loop=loop)
	producer_coro = producer(queue, 3)
	consumer_coro = consumer(queue)
	loop.run_until_complete(asyncio.gather(producer_coro, consumer_coro))
	loop.close()

结果：

produce item_id:0
produce item_id:1
produce item_id:2
consume item_id:0
consume item_id:1
consume item_id:2

伯克利团队关于未来AI系统发展展望

发表于 2018-06-19 分类于机器学习本文字数： 4.1k 阅读时长 ≈ 15 分钟

本文主要根据A Berkeley View of Systems Challenges for AI进行了汇总，以及一些材料上的收集，论文中对未来AI系统以及研究的方向做了非常广泛的讨论。

AI发展的趋势介绍

关键任务(Mission-critical) AI

Mission-critical的含义就是在AI在生活中起到的任务越来越重要，例如自动驾驶、机器人辅助医疗、智能家居等，这些AI的应用非常关键以至于可以影响到人的生死。AI在不断变化的环境中进行部署，必须不断的适应周围环境并学习新的知识。比如自动驾驶需要在处理之前没有遇到过的危险场景中，观察学习其他车辆如何行动从而恰当的处理。另外，关键任务AI也要能处理各种噪音数据以及恶意的攻击。挑战: 不断地与周围动态环境进行互动学习，从而做出及时、鲁棒、安全的决策。

个性化(Personalized) AI

基于用户的个性化决策要考虑到用户自己的习惯与偏好，例如虚拟助理的语音可以模仿用户的口音，自动驾驶可以学习用户的驾驶习惯等。这样的个性化应用需要收集到大量敏感的用户信息，这些信息的滥用可能会造成用户的经济以及精神上的伤害。

挑战: 设计AI系统必须支持个性化的应用，但是这些个性化应用不能损害用户的利益，不能泄露用户的隐私。

跨组织的AI

许多公司在利用第三方的数据去提升他们自己的AI服务能力，例如医院之间的数据共享可以更好的组织传染病的爆发、金融机构之间的数据共享可以更好的进行反欺诈检测。这种应用的扩展使得从一家公司进行数据收集、处理，变成了一个公司使用多方的数据资源来进行决策。

挑战: 设计AI系统需要支持多源数据的训练，这些数据都来自不同的公司或者组织，并在训练过程中保证各家原始数据的机密性，在保证数据机密性的基础上甚至可以提供AI的能力给它的竞争对手。

AI的需求超越了摩尔定律

海量数据的存储和处理是近些年AI系统成功的关键，由于下列两个原因使得后续的数据处理能力很难跟上数据扩张的速度。 * 数据增长是指数级的。IoE设备在2018年采集的数据大小是400ZB，是2015年的50倍，到2025年，需要有3到4个数量级的增长才能处理人类的基因组数据，需要要求接下来的每年计算能力都至少要翻倍。 * 硬件的发展到了瓶颈。需要10年DRAMs和磁盘大小才能翻倍，需要20年CPU的性能才能翻倍。

挑战: 发展领域(domain-specific)的架构和软件系统去满足后摩尔时代性能要求，例如定制的人工智能芯片、高效处理的数据的边缘云计算(edge-cloud)以及数据的采集与抽样方法的发展。

阅读全文 »

FM(Factorization Machines)、FFM(Field-aware Factorization Machines)算法介绍

发表于 2018-06-10 分类于机器学习本文字数： 2.7k 阅读时长 ≈ 10 分钟

高维稀疏场景描述

机器学习中一个通常的预估任务是为了预估一个函数$ y: ^n $，预估过程中使用一组具有实数值的特征向量$ ^n $ 去预测目标 $ $(在回归预估中$ = $, 在分类预估中 $ = +, - $). 高维稀疏场景下向量$ $中大部分元素$ x_i $的值都是0, 我们定义$ m(x) $为向量 $ $ 中非零元素的个数，$ _{D} $为所有向量$ $的$ m(x) $值的平均值。实际中(例如推荐系统)经常会碰到超大规模稀疏的情况($ _{D} n $)。下面举一个例子，假设我们有一个电影的推荐系统，系统中每一条记录表示一个用户($ u U $)在某个时间点($ t $}对一个电影(item)($ i I $)的评分($ r , 2, 3, 4, 5 $). 用户$ U $和电影item $ I $的示例如下: > $ U = Alice(A), Bob(B), Charlie(C), $ > $ I = Titanic (TI), Notting Hill (NH), Star Wars (SW), Star Trek (ST), $ 系统可观测到的用户数据为$ S $示例如下: > $ S = (A, TI, 2010-1, 5), (A, NH, 2010-2, 3), (A, SW, 2010-4, 1), $ > $ (B, SW, 2009-5, 4), (B, ST, 2009-8, 5), (C, TI, 2009-9, 1), (C, SW, 2009-12, 5) $

如下图所示:

图中展示了如何从观测到的用户数据$ S $去创建训练所需要的特征向量的过程，图中蓝色框住的地方表示系统中的用户，每一条记录都表示一个用户的一个行为对$ (u, i, t, r) S $，上面$ S $中的第一条记录$ (A, TI, 2010-1, 5) $，Alice简写为A，在蓝框中$ (x_{A}^{(1)} = 1) $，红色框表示看的电影的item，这里$ x_{TI}^{(1)} = 1 $. 黄色框中表示用户对历史看过的所有的电影的历史评分，这里历史评分的取值经过了归一化操作，归一化以后的值的和为1。绿色表示从09年1月开始计算经历的月份数。深红色的框表示用户上次评价的电影名, 评价过的电影对应的位置设置成1，未评价的设置成0。

阅读全文 »