faiss k-means 暂记

已于 2023-06-08 18:54:34 修改
阅读量1.7k 收藏 5
点赞数 1
分类专栏： 深度学习 文章标签： faiss python 聚类
于 2022-09-07 10:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ResumeProject/article/details/126706801
版权

安装


conda install faiss-gpu=1.5.3 ## python=3.6 可以正常使用k-means的版本

conda install -c pytorch faiss-gpu

#安装gpu版本
#确保已经安装了CUDA，否则会自动安装cup版本。
conda install faiss-gpu -c pytorch # 默认 For CUDA8.0
conda install faiss-gpu cuda90 -c pytorch # For CUDA9.0
conda install faiss-gpu cuda91 -c pytorch # For CUDA9.1

使用

Kmeans

#导入faiss
import sys
sys.path.append('/home/maliqi/faiss/python/')
import faiss

#数据
import numpy as np
d = 512          #维数
n_data = 2000
np.random.seed(0)
data = []
mu = 3
sigma = 0.1
for i in range(n_data):
    data.append(np.random.normal(mu, sigma, d))
data = np.array(data).astype('float32') # 注意数据类型 ！！！

# 聚类
ncentroids = 1024
niter = 20
verbose = True
d = data.shape[1]
kmeans = faiss.Kmeans(d, ncentroids)
kmeans.train(data)

#输出聚类中心
print(kmeans.centroids)

HNSW

向量编码Index

  • 可用的编码是（从最小压缩到最强压缩）：
    完全没有编码（）：向量在没有压缩的情况下存储;IndexFlat
    16 位浮点编码（带）：向量被压缩为 16 位浮点数，这可能会导致一些精度损失;IndexScalarQuantizerQT_fp16
    8/6/4 位整数编码（带 //）：量化为 256/64/16 级的向量;IndexScalarQuantizerQT_8bitQT_6bitQT_4bit
    PQ编码（）：向量被分成子向量，每个子向量被量化为几位（通常为8位）。请参阅下面的示例。IndexPQ
    残差编码（）：向量被量化并通过残差逐步细化。在每个量化阶段，可以细化码本的大小。IndexResidual
    在这里插入图片描述

在这里插入图片描述

Search

            for sent_feat_info in doc_feat[1:]:# 循环句子
                sent_id, sent, sec, text_emb = sent_feat_info

                #text_emb = text_emb.cpu().numpy()
                # fassi feature recall
                emb_text = np.array(text_emb).astype(np.float32)
                D, I = self.index.search(emb_text, topk)# 检索
                res_imgid = [self.imgidx[x] for x in I.tolist()[0]]
                res_sim = D.tolist()[0]
                res_emb = [self.data[x] for x in I.tolist()[0]]

                print (sent, sec, res_imgid)
                doc_fas.append([title, sent, sec, res_imgid, res_sim, res_emb])# 结果转换保存
            out_info.append(doc_fas)
        return out_info

参考与更多

https://faiss.ai/#

faiss documentation python

https://github.com/facebookresearch/faiss/wiki/

faiss中文维基(基础教程)

https://github.com/CCCBora/faiss_chat

  • FAISS Chat: 和本地数据库聊天!
  • https://www.bilibili.com/video/BV11k4y1W7ZE/?

在这里插入图片描述

https://github.com/liqima/faiss_note/blob/master/3.Basics%20%E5%9F%BA%E7%A1%80%E6%A8%A1%E5%9D%97.ipynb

 # faiss implementation of k-means
    clus = faiss.Clustering(d, nmb_clusters)

Faiss building blocks: clustering, PCA, quantization

Runs kmeans on 1 GPU.

Running-on-GPUs
类似的代码

deepcluster = Kmeans(args.n_clusters, knn=1)
clustering_loss, _ = deepcluster.cluster(features, verbose=True)
return deepcluster.centroids, clustering_loss

class Kmeans:
    def __init__(self, k, knn=1):
        self.k = k
        self.knn = knn
        self.centroids = None
        self.labels = None
        self.images_lists = []
        self.dists = None

    def cluster(self, data,  verbose=False):
        """Performs k-means clustering.
            Args:
            x_data (np.array N * dim): data to cluster
        """
        start = time.time()
        # cluster the data
        labels, loss, self.centroids, self.dists = run_kmeans(data, self.k, verbose, self.knn)
        self.labels = labels
        self.images_lists = [[] for i in range(self.k)]
        for i in range(len(data)):
            self.images_lists[labels[i]].append(i)

        if verbose:
            print('k-means time: {0:.0f} s'.format(time.time() - start))

        return loss, self.dists

def run_kmeans(x, nmb_clusters, verbose=False, knn=1):
    """Runs kmeans on 1 GPU.
    Args:
        x: data
        nmb_clusters (int): number of clusters
    Returns:
        list: ids of data in each cluster
    """
    n_data, d = x.shape # 560900 , 1152

    # faiss implementation of k-means
    nmb_clusters = int(nmb_clusters)
    clus = faiss.Clustering(d, nmb_clusters) # d=1152,nmb_clusters=10
    clus.niter = 30
    clus.max_points_per_centroid = 10000000
    res = faiss.StandardGpuResources()
    flat_config = faiss.GpuIndexFlatConfig()
    flat_config.useFloat16 = False
    flat_config.device = 0
    index = faiss.GpuIndexFlatL2(res, d, flat_config)

    # perform the training
    clus.train(x, index) # ndarray(560900,1152)
    dists, labels = index.search(x, knn)
    losses = faiss.vector_to_array(clus.obj)
    centroids = faiss.vector_float_to_array(clus.centroids).reshape(nmb_clusters, d)
    if verbose:
        print('k-means loss evolution: {0}'.format(losses))

    return [int(n[0]) for n in labels], losses[-1], centroids, dists

import time
import faiss
import torch
import numpy as np


def compute_features(dataloader, model, args, use_predict_fn=False, concat_vid=False, keep_dim=False):
    cargs = args
    if cargs.verbose:
        print('Compute features')
    start = time.time()
    model.eval()
    features = []
    # discard the label information in the dataloader
    for i, data_arr in enumerate(dataloader):
        pose_data = data_arr[0]
        with torch.no_grad():
            data = pose_data.to(args.device)
            if use_predict_fn:
                pose_features = model.predict(data).data.to('cpu', non_blocking=True).numpy()
                pose_features = pose_features.reshape(-1, 1)
            else:
                pose_features = model(data)
                if isinstance(pose_features, (list, tuple)):
                    pose_features = pose_features[0]
                pose_features = pose_features.data.to('cpu', non_blocking=True).numpy()

        if concat_vid:  # Concatenate each clip's video features to its pose embedding
            vid_features = data_arr[1]
            batch_features = np.concatenate([pose_features, vid_features], axis=1)
        else:
            batch_features = pose_features

        features.append(batch_features)

        # measure elapsed time
        batch_time = time.time() - start
        start = time.time()

        if cargs.verbose and (i % 200) == 0:
            print('{0} / {1}\t'
                  'Time: {batch_time:.3f})'
                  .format(i, len(dataloader), batch_time=batch_time))
    features = np.concatenate(features)
    if keep_dim:
        n, c, t, v = data.size()
        features = features.reshape(features.shape[0], -1, v)
    return features


class Kmeans:
    def __init__(self, k, knn=1):
        self.k = k
        self.knn = knn
        self.centroids = None
        self.labels = None
        self.images_lists = []
        self.dists = None

    def cluster(self, data,  verbose=False):
        """Performs k-means clustering.
            Args:
            x_data (np.array N * dim): data to cluster
        """
        start = time.time()
        # cluster the data
        labels, loss, self.centroids, self.dists = run_kmeans(data, self.k, verbose, self.knn)
        self.labels = labels
        self.images_lists = [[] for i in range(self.k)]
        for i in range(len(data)):
            self.images_lists[labels[i]].append(i)

        if verbose:
            print('k-means time: {0:.0f} s'.format(time.time() - start))

        return loss, self.dists


def run_kmeans(x, nmb_clusters, verbose=False, knn=1):
    """Runs kmeans on 1 GPU.
    Args:
        x: data
        nmb_clusters (int): number of clusters
    Returns:
        list: ids of data in each cluster
    """
    n_data, d = x.shape

    # faiss implementation of k-means
    nmb_clusters = int(nmb_clusters)
    clus = faiss.Clustering(d, nmb_clusters)
    clus.niter = 30
    clus.max_points_per_centroid = 10000000
    res = faiss.StandardGpuResources()
    flat_config = faiss.GpuIndexFlatConfig()
    flat_config.useFloat16 = False
    flat_config.device = 0
    index = faiss.GpuIndexFlatL2(res, d, flat_config)

    # perform the training
    clus.train(x, index)
    dists, labels = index.search(x, knn)
    losses = faiss.vector_to_array(clus.obj)# !!!
    centroids = faiss.vector_float_to_array(clus.centroids).reshape(nmb_clusters, d)
    if verbose:
        print('k-means loss evolution: {0}'.format(losses))

    return [int(n[0]) for n in labels], losses[-1], centroids, dists



if __name__ == "__main__":
    data = np.random.randn(560900,1152)
    labels, loss, centroids, dists = run_kmeans(data, 10, verbose=True, knn=1)
    print(123)

https://pypi.tuna.tsinghua.edu.cn/simple/faiss-gpu/

在这里插入图片描述

geng

video:Milvus 问答 #12：新版本、Postgres向量检索插件、比Faiss好用？

Python faiss.Clustering方法代码示例

  • Classification is a Strong Baseline for Deep Metric Learning (BMVC '19)
    深度度量学习旨在学习一种将图像像素映射到嵌入特征向量的函数，该特征向量对图像之间的相似性进行建模。度量学习的两个主要应用是基于内容的图像检索和人脸验证。对于检索任务，大多数当前最先进的（SOTA）方法是基于三元组的非参数化训练。然而，对于人脸验证任务，最近的SOTA方法采用了基于分类的参数化训练。在本文中，我们研究了基于分类的方法在图像检索数据集上的有效性。我们评估了几个标准检索数据集，如CAR-196，CUB-200-2011，斯坦福在线产品和In-Shop数据集，用于图像检索和聚类，并确定我们基于分类的方法在不同的特征维度和基本特征网络中具有竞争力。我们进一步深入分析了子采样类的性能效应，以实现可扩展的基于分类的训练，以及二值化的影响，从而为实际应用提供高效的存储和计算。

  • 当数据很多，聚类中心也很多时无法正常运行kmeans_pytorch

  • https://github.com/DeMoriarty/fast_pytorch_kmeans

# pip install fast-pytorch-kmeans


from fast_pytorch_kmeans import KMeans
import torch
import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

kmeans = KMeans(n_clusters=8, mode='euclidean', verbose=1)
x = torch.randn(100000, 64, device='cuda').float()
labels = kmeans.fit_predict(x)


# Traceback (most recent call last):
#   File "/---/ubuntu/---/---/gepc-master/fasttest.py", line 12, in <module>
#     labels = kmeans.fit_predict(x)
#   File "/home/ubuntu/anaconda3/envs/ngepc/lib/python3.6/site-packages/fast_pytorch_kmeans/kmeans.py", line 215, in fit_predict
#     self.num_points_in_clusters[matched_clusters] += counts
# RuntimeError: expected device cuda:0 and dtype Float but got device cuda:0 and dtype Long
FakeOccupational
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用faiss实现kmeans聚类算法
weixin_39417324的博客
07-27 2816
Ubuntu安装faiss： conda install faiss-cpu -c pytorch conda install faiss-gpu cudatooklkit=10.0 -c pytorch 实现kmeans其实主要就是两句代码 import faiss import pickle import numpy as np import time #x是用numpy生成的一个200*100的矩阵 x = np.random.random((200, 100)).astype('float3
K-means实现广告聚类分析.zip
11-19
项目包含广告渠道90天内额日均UV，平均注册率、平均搜索率、访问深度、平均停留时长、订单转化率、投放时间、素材类型、广告类型、合作方式、广告尺寸和广告卖点等特征，将渠道分类，找出每类渠道的重点特征，为业务...
K-means以及Faiss聚类
sandrew0916的博客
04-07 3423
K-means K-means 是我们最常用的基于欧式距离的聚类算法，其认为两个目标的距离越近，相似度越大。 算法步骤： 1.选择初始化的k个样本作为初始聚类中心 :a=a1,a2,...aka=a_1,a_2,...a_ka=a1​,a2​,...ak​; 2.针对数据集中每个样本xix_ixi​，计算它到k个聚类中心的距离，并将其分到距离最小的聚类中心所对应的类中； 3.针对每个类别aja_jaj​，重新计算它的聚类中心aj=1ci∑x∈cixa_j=\frac{1}{c_i}\sum_{x\in{c_
【Python/Pytorch 】-- K-means聚类算法
最新发布
银尘博客
06-21 1342
时间演变聚类算法：将时间演变聚类算法用在去噪上，基本思想是，具有相似信号演化的体素具有相似的模型参数值，并且由机器学习决定的集群数量远远小于体素的数量。因此，对一个聚类进行平均可以大大提高聚类级逆解的信噪比，这可以用作体素级优化的鲁棒初始猜测。在该演变算法的基础上，总结了K-means算法、X-means算法、最小二乘法、贝叶斯信息准则。
Faiss教程：基础
weixin_33748818的博客
07-16 896
Faiss对一些基础算法提供了非常高效的实现：k-means、PCA、PQ编解码。 聚类 假设2维tensor x： ncentroids = 1024 niter = 20 verbose = True d = x.shape[1] kmeans = faiss.Kmeans(d, ncentroids, niter, verbose) kmeans.train(x) 中心点放在kmeans.c...
一文搞懂faiss计算
06-22 2832
Faiss的全称是Facebook AI Similarity Search。 这是一个开源库，针对高维空间中的海量数据，提供了高效且可靠的检索方法。 暴力检索耗时巨大，对于一个要求实时人脸识别的应用来说是不可取的。 而Faiss则为这种场景提供了一套解决方案。 Faiss从两个方面改善了暴力搜索算法存在的问题：降低空间占用加快检索速度首先， Faiss中提供了若干种方法实现数据压缩，包括PCA、Product-Quantization等。 （1）对于一个检索任务，我们的操作流程一定分为三步：训练、构.
坑 之 Ubuntu Conda虚拟环境使用faiss-gpu报错分析及解决办法
qq_41368074的博客
05-16 5754
faiss-gpu的使用于cuda版本是紧密相关的，cuda又是与nvidia driver紧密相关的，nvidia driver又是与显卡紧密相关的
向量检索（一）Faiss 在工业界的应用和常见问题解决
千里之行
11-07 8669
传统的搜索，使用关键做精确的查找，利用倒排索引在索引库中搜索。日常在用的百度，Google都属于关键词搜索。 在 AI 时代我们需要查找一张相似的图片，一个问题的答案，或者根据一段音乐查找对应的歌曲，这些情况下没有准确的关键词用来做检索。 这些图片，问题（文本），语音，不再是简单的一个一维量化的数字，而是包含了大量的属性特征。 因而不合适使用传统的关键字搜索引擎来查找。 对于文本，图片，语音，视频，DNA信息等等，都可用向量来表示，数据被特征化处理后用来表示这条数据的向量称之为 Embedding
k-means算法课件ppt
09-28
k-means算法是一种广泛应用的无监督学习方法，主要用于数据聚类。它的主要目标是将数据集分割成k个不同的簇，使得每个数据点都尽可能接近其所在簇的中心，而不同簇之间的数据点尽可能远离。在讲解k-means算法时，...
K-means.rar_K._k-means聚类算法
07-14
K-means算法是一种广泛应用的无监督机器学习方法，主要用于数据的聚类分析。它通过将数据集中的样本点分配到预先设定的K个类别中，使得每个类别的内部数据相似度最大，而不同类别间的差异性最大。在这个“K-means....
K-Means-improvement_k-means_K均值_K._
10-02
K均值（K-Means）算法是一种广泛应用的无监督学习方法，主要用于数据聚类。在数据挖掘和机器学习领域，K-Means因其简单、高效的特点而备受青睐。其核心思想是通过迭代将数据点分配到最近的聚类中心，从而形成K个簇。...
K-means聚类算法.ppt
10-26
PPT用于初步理解K-means算法，且基于K-means算法衍生出了三类算法：K-medoids,k-means++,FCM。该PPT的传输来自导师的资源分享，不涉及商用，用于大家对K-means算法的理解。如有侵权，本人将撤销资源上传。以上。
【[2020.6] 数据挖掘：基于Spark框架的K-Means聚类1】Win10下配置Spark环境+Anaconda/Python安装pyspark，超详细
moyang的博客
06-21 904
【数据挖掘：基于Spark框架的K-Means聚类1 [2020.6]】Win10下配置Spark环境+Anaconda安装pyspark，超详细Spark框架介绍Win10下Anaconda安装pyspark如何插入一段漂亮的代码片 Spark框架介绍 Spark框架的介绍离不开Hadoop框架，关于大数据框架的起源以及Hadoop与Spark的介绍在文章《Hadoop与Spark等大数据框架介绍》中已经很详尽了，这里不再赘述。 Hadoop：Hadoop的核心是HDFS和Mapreduce，hadoop
基于text2vec 和 fast-pytorch-kmeans 的文本聚类实现，利用GPU加速提高聚类速度
sjxgghg的博客
03-14 1620
使用text2vec模型，把文本转成向量。使用text2vec训练好的模型权重进行文本编码，不重新训练word2vec模型。利用pytorch在cuda上加速聚类计算。
推荐：Fast Pytorch Kmeans - 高效的PyTorch聚类库
gitblog_00056的博客
05-27 344
推荐：Fast Pytorch Kmeans - 高效的PyTorch聚类库 fast_pytorch_kmeansThis is a pytorch implementation of k-means clustering algorithm项目地址:https://gitcode.com/gh_mirrors/fa/fast_pytorch_kmeans 在大数据和机器学习领域，快速而准确的...
Windows 使用aconda安装faiss-gpu
qq_39172320的博客
07-07 680
windows使用aconda 安装faiss
【安装教程】windows下安装Faiss-GPU
weixin_42421914的博客
03-07 2583
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
faiss简介及示例
热门推荐
JC的博客
06-22 5万+
简介 faiss是为稠密向量提供高效相似度搜索和聚类的框架。由Facebook AI Research研发。 具有以下特性。 1、提供多种检索方法 2、速度快 3、可存在内存和磁盘中 4、C++实现，提供Python封装调用。 5、大部分算法支持GPU实现 下面给出一些快速链接方便查找更多内容。 github 官方文档 c++类信息 Troubleshooting 官方安装文档...
k-means++和k-means||
铭霏的记事本
08-15 1万+
一、k-means算法缺点: 1、需要提前指定k 2、k-means算法对初始化非常敏感 k-means++主要用来解决第二个缺点 二、k-means++算法原理分析 k-means++算法选择初始聚类中心的基本原则是：初始的聚类中心之间的相互距离要尽可能的远。它选择初始聚类中心的步骤是： （1）从输入的数据点集合中随机选择一个点作为第一个聚类中心； （2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值