精华内容
下载资源
问答
  • pytorch人脸识别
    2021-02-05 04:21:14

    importtorch as tfrom torch.utils importdataimportosfrom PIL importImageimportnumpy as npfrom torchvision importtransforms as Tfrom torch importnnfrom torch.autograd importVariablefrom torch.optim importAdamfrom torchvision.utils importmake_gridfrom torch.utils.data importDataLoader

    transform= T.Compose( #归一化

    [

    T.Resize(1000),

    T.CenterCrop(1000),

    T.ToTensor(),

    T.Normalize(mean=[.5,.5,.5],std=[.5,.5,.5])

    ]

    )#在这个class里重写你的数据集

    classtwoface(data.Dataset):def __init__(self,root,transforms=None):

    imgs=os.listdir(root)

    self.imgs= [os.path.join(root,img) for img inimgs]

    self.transforms=transformsdef __getitem__(self, index):

    img_path=self.imgs[index]

    label= 1 if 'empty' in img_path.split('/')[-1] else 0 #定义标签:图片名中有label

    data =Image.open(img_path)ifself.transforms:

    data=self.transforms(data)returndata,labeldef __len__(self):returnlen(self.imgs)

    dataset= twoface('./data1/',transforms=transform) #transform 用在这里

    data_loader_train = t.utils.data.DataLoader(dataset=dataset,

    batch_size=1, #batch_size 要=1

    shuffle=True,

    num_workers=0)

    data_loader_test= t.utils.data.DataLoader(dataset=dataset,

    batch_size=1,

    shuffle=True,

    num_workers=0)classModel(t.nn.Module):def __init__(self):

    super(Model, self).__init__()

    self.conv1= t.nn.Sequential(t.nn.Conv2d(3, 6, kernel_size=20, stride=10, padding=0), #模型这块如果你图片格式不对的话要重新算

    t.nn.ReLU(),

    t.nn.Conv2d(6, 10, kernel_size=6, stride=1, padding=0),

    t.nn.ReLU(),

    t.nn.Conv2d(10, 16, kernel_size=5, stride=1, padding=0),

    t.nn.ReLU(),

    t.nn.MaxPool2d(stride=5, kernel_size=5))# self.dense = t.nn.Sequential(t.nn.Linear(18 * 18 * 16, 33),

    t.nn.ReLU(),

    t.nn.Linear(33, 2)

    )defforward(self, x):

    x=self.conv1(x)

    x= x.view(-1,18 * 18 * 16)

    x=self.dense(x)returnx

    model=Model().cuda()print(model)

    cost=t.nn.CrossEntropyLoss()

    optimizer=t.optim.Adam(model.parameters())

    n_epochs= 5

    for epoch in range(n_epochs):

    running_loss= 0.0running_correct=0print("Epoch {}/{}".format(epoch, n_epochs))print("-" * 10)for datas indata_loader_train:

    realone,label=datas

    realone, label=Variable(realone).cuda(), Variable(label).cuda()

    output=model(realone)

    _,pred= t.max(output.data,1)

    optimizer.zero_grad()

    loss=cost(output, label)

    loss.backward()

    optimizer.step()

    running_loss+=loss.data[0]

    running_correct+= t.sum(pred ==label)

    testing_correct=0for datak indata_loader_test:

    X_test, y_test=datak

    X_test, y_test=Variable(X_test).cuda(), Variable(y_test).cuda()

    outputs=model(X_test)

    _, pred= t.max(outputs.data, 1)

    testing_correct+= t.sum(pred ==y_test.data)print("Loss is:{:.4f}, Train Accuracy is:{:.4f}%, Test Accuracy is:{:.4f}".format(running_loss /len(dataset),100 * running_correct /len(

    dataset),100 * testing_correct /len(

    dataset)))

    t.save(model,'ifempty.pkl')

    更多相关内容
  • pytorch 人脸识别

    千次阅读 2021-01-27 19:33:29
    import torch import os import numpy as np import torch.nn as nn import matplotlib.pyplot as plt import time ...#训练集在train文件夹下,每种类别的人脸都位于同一个子目录下。验证集数据类似 data_d
    import torch
    import os
    import numpy as np
    import torch.nn as nn
    import  matplotlib.pyplot as plt
    import time
    import torchvision
    from torchvision import  transforms,models,datasets
    import torch.optim as optim
    
    #训练集在train文件夹下,每种类别的人脸都位于同一个子目录下。验证集数据类似
    data_dir="F:/muct人脸数据库_项目"
    train_dir=data_dir+"/train"
    valid_dir=data_dir+"/valid"
    
    
    data_transform=transforms.Compose(
            [
                transforms.Resize(224),
                transforms.ToTensor(),
                transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
            ]
        )
    
    #加载数据
    image_datasets={
        x:torchvision.datasets.ImageFolder(os.path.join(data_dir,x),
        transform=data_transform)for x in ["train","valid"]
    }
    
    dataLoaders={x:torch.utils.data.DataLoader(image_datasets[x],
                 batch_size=4,shuffle=True)for x in ["train","valid"]
    }
    
    #使用GPU
    device=torch.device("cuda")
    
    #加载模型
    model=torchvision.models.resnet152(True)
    #冻住模型中的参数
    for param in model.parameters():
        param.requires_grad=False
    
    #修改最后的全连接层,使其适应咱们的项目-276分类
    #in_features是全连接层中的输入的维数
    num_fts=model.fc.in_features
    model.fc=nn.Linear(num_fts,276)
    
    
    #将模型加载到GPU
    model=model.to(device)
    
    #设置优化器
    optimizer=optim.Adam(model.fc.parameters(),lr=1e-2)
    
    #损失函数
    criterion=nn.CrossEntropyLoss()
    
    for epoch in range(5):
        print("Epoch:", epoch)
        print("---" * 5)
        for phase in ["train","valid"]:
            rightnumber = 0
            rightacc = 0
            if phase =="train":
                model.train()
            else:
                model.eval()
    
             # 把数据都取个遍
            for inputs, labels in dataLoaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)
    
                # 清零
                optimizer.zero_grad()
                # 只有训练的时候计算和更新梯度
                with torch.set_grad_enabled(phase == 'train' or phase == 'valid'):
                    outputs = model(inputs)
                    loss = criterion(outputs, labels)
                    _, preds = torch.max(outputs, 1)
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
    
                    # 计算损失
                    rightnumber+= torch.sum(preds == labels.data)
    
                rightacc = rightnumber.double() / len(dataLoaders[phase].dataset)
            print(rightacc.item())
    
    展开全文
  • PyTorch人脸识别+Flask

    2022-06-22 17:37:20
    Pytorch人脸识别与Flask相结合

    一、任务目标

    1. 实现一个Flask网页 连接数据库 将单词表打印在网页中
    2. 再实现一个Flask网页 将人脸识别的内容放入到网页中 具体来说需要包含以下内容:
      ① 匹配还是不匹配
      ② 原图
      ③ 人脸对齐 人脸识别后的识别结果图
      ④ 人脸的特征向量

    二、任务一

    1. 连接库

    代码如下:

    import MySQLdb
    import pandas as pd
    from flask import Flask, jsonify
    import time
    
    # 连接数据库
    db = MySQLdb.connect("127.0.0.1", "username", "password", "database", charset='utf8' )
    cursor = db.cursor()
    

    2. 创建flask服务和页面

    代码如下:

    # 创建服务
    app = Flask(__name__)
    app.config['JSON_SORT_KEYS'] = False
    
    @app.route("/") 
    def getmovies():
        sql = "select * from map_enword;"
        cursor.execute(sql)
        rs=cursor.fetchall()
        rs=list(rs)
        result = "<h1>词表</h1>"
        result+="<body>"
        for r in rs:
            result+="<br>"
            result+=str(tuple(r))+"<br/>"
        result+="<body/>"
        return result
    

    3. main函数

    代码如下:

    if __name__ == '__main__':
        try:
            app.run(host='127.0.0.1', port=5000, debug=True)
        except:
            print("network outage")
        finally:
            cursor.close()
            db.close()
    

    3. 注意事项

    注意,在程序结束后,关闭程序与数据库的连接,即“cursor.close()”、“db.close()”

    4. 结果展示

    在这里插入图片描述

    二、任务二

    1. 人脸匹配子函数

    代码如下:

    import cv2
    import torch
    from facenet_pytorch import MTCNN, InceptionResnetV1
    import face_recognition
    import dlib
        
    def match_faces(faces_emb, known_faces_emb, threshold):
        isExistDst = False
        distance = (known_faces_emb[0] - faces_emb[0]).norm().item()
        if(distance < threshold):
            isExistDst = True
        return isExistDst
        
    def detect(filename):
        face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
        img = cv2.imread(filename)
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.3, 5)    
        for (x, y, w, h) in faces:
            img = cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
        cv2.imwrite("result2.jpg",img)
    

    2. 人脸识别子函数

    代码如下:

    def face1():
        image = face_recognition.load_image_file("test1.jpg",mode ='RGB')
        face_locations_noCNN=face_recognition.face_locations(image)
        face_recognition.face_locations(image,model='cnn')
    
        face_num2=len(face_locations_noCNN)
        print(face_num2)       # The number of faces
    
        org = cv2.imread("test1.jpg")
        img = cv2.imread("test1.jpg")
    
        for i in range(0,face_num2):
            top = face_locations_noCNN[i][0]
            right = face_locations_noCNN[i][1]
            bottom = face_locations_noCNN[i][2]
            left = face_locations_noCNN[i][3]
            start = (left, top)
            end = (right, bottom)
            color = (0,255,255)
            thickness = 2
            cv2.rectangle(org, start, end, color, thickness)
        cv2.imwrite("origin.jpg",img)
        cv2.imwrite("result1.jpg",org)
    

    3. 人脸对齐子函数

    代码如下:

    def face2():
        path = "test1.jpg"
        img = cv2.imread(path)
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        detector = dlib.get_frontal_face_detector()
        dets = detector(gray, 1)
        predictor = dlib.shape_predictor("C:\\software\\anaconda3\\Lib\\site-packages\\shape_predictor_68_face_landmarks.dat")
        for face in dets:
            shape = predictor(img, face) 
            for pt in shape.parts():
                pt_pos = (pt.x, pt.y)
                cv2.circle(img, pt_pos, 2, (0, 255, 0), 1)
            cv2.imwrite("result3.jpg",img)
        return 
    

    3. 人脸特征向量子函数

    代码如下:

    def load_known_faces(dstImgPath, mtcnn, resnet, device):
        aligned = []
        knownImg = cv2.imread(dstImgPath)
        face = mtcnn(knownImg)  
        if face is not None:
            aligned.append(face[0])
        aligned = torch.stack(aligned).to(device)
        with torch.no_grad():
            known_faces_emb = resnet(aligned).detach().cpu() 
        return known_faces_emb, knownImg
    

    4. Flask融合展示

    代码如下:

    from flask import Flask, Response
    app = Flask(__name__)
    
    @app.route('/<imageId>')
    def get_image1(imageId):
        with open(r'{}'.format(imageId), 'rb') as f:
            image = f.read()
            result = Response(image, mimetype="image/jpg")
        return result
    
    @app.route('/face')
    def hello_world():
        result="<body>"
        result+='<br>人脸匹配结果:<br/>'
        device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
        mtcnn = MTCNN(min_face_size=12, thresholds=[0.2, 0.2, 0.3],keep_all=True, device=device)
        resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device)
        MatchThreshold = 0.8 
        known_faces_emb, _ = load_known_faces('lyf.jpg',mtcnn, resnet, device)  
        faces_emb, img = load_known_faces('lyf2.jpg', mtcnn,resnet, device)
        isExistDst = match_faces(faces_emb, known_faces_emb, MatchThreshold)
    
        if isExistDst:
            boxes, prob, landmarks = mtcnn.detect(img, landmarks=True)  
            result+='<br>匹配<br/>'
        else:
            result+='<br>不匹配<br/>'
    
        result+='<br>原图<br/>'
        result+='<img src="origin1.jpg" alt="">'
            
        face1()
        result+='<br>cv2人脸识别结果:<br/>'
        result+='<img src="result2.jpg" alt="">'
        
        detect('test1.jpg')
        result+='<br>face_recognition人脸识别结果:<br/>'
        result+='<img src="result1.jpg" alt="">'
        
        face2()
        result+='<br>人脸对齐结果:<br/>'
        result+='<img src="result3.jpg" alt="">'
        
        result+='<br>人脸的特征向量:<br/>'
        result+='<br>'
        result+=str(faces_emb)
        result+='<br/>'
        
        result+='</body>'
        return result
            
            
    if __name__=='__main__':
        app.run(debug=True,port=9989,use_reloader=False)
    

    该处使用的url网络请求的数据。

    5. 注意事项

    注意,当一个flask网页调用一个图片时,图片的调用路径不是该程序文件的位置,而使“127.0.0.1:5000/< imageId>",因此需要建立个图片的flask网页,该网页中使用Response获取本地图片。

    6. 结果展示

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    三、总结

    成功完成实验目标,总体较为顺利,遇到的问题也通过查阅网络资料解决了。

    展开全文
  • web开发入门,分别用pytorch进行人脸识别,python连接数据库,并将结果在flask里展示

    PyTorch人脸识别+Flask连接数据库


    前言

    本文介绍了人脸识别的几种基本使用方法,并使用flask框架进行展示。
    实验要求:
    1.实现一个Flask网页 连接数据库 将单词表打印在网页中。
    2.再实现一个Flask网页 将人脸识别的内容放入到网页中,具体来说需要包含以下内容:
    ①匹配还是不匹配
    ②原图
    ③人脸对齐 人脸识别后的识别结果图
    ④人脸的特征向量


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、flask是什么?

    flask是⼀款⾮常流⾏的 轻量级 Python Web应⽤框架。
    Web应⽤框架:⽤于进⾏Web开发的⼀套软件架构,提供了⼀套开发和部署⽹站的⽅式
    ⻚⾯:以HTML的形式发送到浏览器中
    发送HTML到浏览器的应⽤:Web应⽤

    二、实验过程

    1.连接数据库并查询需要的数据

    代码如下(示例):

    # 导⼊pymysql模块
    import pymysql
    # 连接database,这部分改成自己的数据库
    conn = pymysql.connect(
        host="localhost",#数据库的链接,一般都是localhost,可以打开自己的mysql查一下
        port=3306,#端口号
        user="root",password="123456",#用户名和密码
        database="flask2022",#使用的数据库
        charset="utf8")
    # 得到⼀个可以执⾏SQL语句的光标对象
    cursor = conn.cursor()
    # 执⾏完毕返回的结果集默认以元组显示
    # 得到⼀个可以执⾏SQL语句并且将结果作为字典返回的游标
    #cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
    # 定义要执⾏的SQL语句
    # 查询全部
    sql1 = "select * from map_enword"
    # 按条件查询
    sql = "SELECT * FROM course WHERE cid > %d" % (1)
      # 异常处理
    try:
        cursor.execute(sql1)
        results = cursor.fetchall()
        print(results)
    except:
        conn.rollback()
    # 关闭光标对象
    cursor.close()
    # 关闭数据库连接
    conn.close()
    

    运行结果:注意是以元组的形式返回数据库里的
    执行结果

    2.人脸识别

    上一篇博客介绍了几种常见的人脸识别方法,详见:
    python人脸识别
    本文介绍一种新的方法,使用mtcnn进行人脸识别,可以读取两张图片获得它们的特征向量,并匹配是不是同一人。
    代码如下(示例):

    import cv2
    import torch
    from facenet_pytorch import *
    
    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    def load_known_faces(dstImgPath, mtcnn, resnet):
        aligned = []
        knownImg = cv2.imread(dstImgPath) # 读取图片
        face = mtcnn(knownImg) # 使用mtcnn检测人脸,返回【人脸数组】
        if face is not None:
            aligned.append(face[0])
        aligned = torch.stack(aligned).to(device)
        with torch.no_grad():
            known_faces_emb = resnet(aligned).detach().cpu() # 使用resnet模型获取人脸对应的特征向量
        return known_faces_emb, knownImg
    def match_faces(faces_emb, known_faces_emb, threshold):
        isExistDst = False
        distance = (known_faces_emb[0] - faces_emb[0]).norm().item()
        if(distance < threshold):
            isExistDst = True
        return isExistDst
    
    
    if __name__ == '__main__':
     
        # mtcnn模型加载【设置网络参数,进行人脸检测】
        mtcnn = MTCNN(min_face_size=12, thresholds=[0.2, 0.2, 0.3],
        keep_all=True, device=device)
        # InceptionResnetV1模型加载【用于获取人脸特征向量】
        resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device)
        MatchThreshold = 0.8 # 人脸特征向量匹配阈值设置
        # 注意图片路径
        known_faces_emb, _ = load_known_faces('lyf.jpg',
        mtcnn, resnet) # 已知人物图
        faces_emb, img = load_known_faces('lyf2.jpg', mtcnn,
        resnet) # 待检测人物图
        isExistDst = match_faces(faces_emb, known_faces_emb, MatchThreshold)
        # 人脸匹配
        if isExistDst:
            boxes, prob, landmarks = mtcnn.detect(img, landmarks=True) # 返
            print('匹配')
        else:
            print('不匹配')
    

    输入:
    lyf.jpg
    lyf.jpg
    lyf2.jpg
    lyf2.jpg
    运行结果:
    运行结果

    3.使用flask进行展示

    3.1 路由函数

    我们将上述的运行结果在flask里进行展示,首先是写路由。将1和2中的部分代码放在路由函数里进行展示。
    main.py

    from flask import Flask, render_template
    app = Flask(__name__) # 初始化Flask实例
    import pymysql
    from getface import *
    import cv2
    import torch
    from facenet_pytorch import *
    
    @app.route('/') # 路由
    def hello_world(): # 视图函数
        return 'hello world'
    # 理解路由
    @app.route('/user')
    def hello_user():
        return 'hello user'
    
    @app.route('/word')
    def word():
        conn = pymysql.connect(
            host="localhost",
            port=3306,
            user="root", password="123456",
            database="flask2022",
            charset="utf8")
        # 得到⼀个可以执⾏SQL语句的光标对象
        cursor = conn.cursor()
        # 执⾏完毕返回的结果集默认以元组显示
        # 得到⼀个可以执⾏SQL语句并且将结果作为字典返回的游标
        # cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
        # 定义要执⾏的SQL语句 #创建数据表
        # 显示全部
        sql1 = "select * from map_enword"
        try:
            cursor.execute(sql1)
            results = cursor.fetchall()
            results = list(results)
        except:
            conn.rollback()
        # 关闭光标对象
        cursor.close()
        # 关闭数据库连接
        conn.close()
        return render_template('words.html',result=results)#将result结果传入模板
    
    @app.route('/face')
    def face():
        device = torch.device('cuda:0' if torch.cuda.is_available() else
                        'cpu')
        # mtcnn模型加载【设置网络参数,进行人脸检测】
        mtcnn = MTCNN(min_face_size=12, thresholds=[0.2, 0.2, 0.3],
                      keep_all=True, device=device)
        # InceptionResnetV1模型加载【用于获取人脸特征向量】
        resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device)
        MatchThreshold = 0.8  # 人脸特征向量匹配阈值设置
        # 注意图片路径
        known_faces_emb, _ = load_known_faces('static/zgr1.jpeg',
                                              mtcnn, resnet)  # 已知人物图
        faces_emb, img = load_known_faces('static/zgr2.jpeg', mtcnn,
                                          resnet)  # 待检测人物图
        isExistDst = match_faces(faces_emb, known_faces_emb, MatchThreshold)
        # 人脸匹配
        if isExistDst:
            boxes, prob, landmarks = mtcnn.detect(img, landmarks=True)
            mm='匹配'
        else:
            mm='不匹配'
        return render_template('face.html', feature1=known_faces_emb,feature2=faces_emb,match_result=mm)#将需要展示的数据传入模板
    if __name__ == '__main__':
        print("yes") # 控制台输出
        app.run(debug=True)
    

    3.2使用模板

    我们写两个Html文件分布展示单词表和人脸识别结果。

    1. face.html
      python人脸识别介绍了人脸识别和人脸对齐的过程,本文不再赘述,直接将其结果保存下来进行展示。
    <!DOCTYPE html>
    
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <h1>已知人物图</h1>
        <h3>原图</h3>
        <img src="../static/zgr1.jpeg">
        <h3>人脸对齐</h3>
        <img src="../static/zgr1_fp.jpg">
        <h3>人脸识别</h3>
        <img src="../static/zgr1_fr.jpg">
        <h3>人脸的特征向量</h3>
        {{feature1}}
        <h1>待检测人物图</h1>
        <h3>原图</h3>
        <img src="../static/zgr2.jpeg">
        <h3>人脸对齐</h3>
        <img src="../static/zgr2_fp.jpg">
        <h3>人脸识别</h3>
        <img src="../static/zgr2_fr.jpg">
        <h3>人脸的特征向量</h3>
        {{feature2}}
        <h1>匹配结果</h1>
        {{match_result}}
    </body>
    </html>
    

    return render_template(‘face.html’, feature1=known_faces_emb,feature2=faces_emb,match_result=mm)#将需要展示的数据传入模板
    注意{{}}内是从路由函数传来的参数

    2.words.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <h1>单词表</h1>
        {% for r in result %}
            {{r}}<br>
        {% endfor %}
    </body>
    </html>
    

    4.结果展示

    运行main.py,会显示网页的地址
    运行结果1点击后记得输入正确的路由,分别输入word和face
    1http://127.0.0.1:5000/face
    1234http://127.0.0.1:5000/word

    5

    总结

    本文介绍了flask的基本使用方法,包括路由的使用,模板的使用,与数据库的连接,并介绍了一种新的基于pytorch的人脸识别方法,并将结果在flask网页中展示。

    展开全文
  • 基于“ VGGFace2:用于识别跨姿势和年龄的面部表情的数据集”的PyTorch面部表情识别器。 此仓库实现了培训和测试模型,并基于VGGFace2 [1]的模型构建了特征提取器。 是从[1]的作者提供的转换而来的。 数据集 要...
  • 使用Pytorch实现ResNet50进行跨年龄人脸识别
  • Deep learning face detection and recognition, implemented by pytorch. (pytorch实现的人脸检测和人脸识别)
  • 使用Pytorch进行人脸识别 Python 3.7 3.6 3.5 地位 这是pytorch中Inception Resnet(V1)模型的存储库,已在VGGFace2和CASIA-Webface上进行了预训练。 使用从David Sandberg的移植的参数来初始化Pytorch模型...
  • 基于Pytorch人脸识别系统.pdf
  • 使用Pytorch Python 3.7 3.6 3.5状态的人脸识别这是pytorch中Inception Resnet(V1)模型的存储库,已在VGGFace2和CASIA上进行了预训练-我们使用Pytorch Python 3.7 3.6 3.5状态这是用于Inception Resnet(V1)模型...
  • 基于facenet_pytorch判断两张人脸的欧氏距离,从而实现人脸识别
  • 基于PyTorch人脸识别框架(翻译)

    千次阅读 2021-11-08 11:03:48
    基于PyTorch人脸识别框架 Face recognition framework based on PyTorch. 一、介绍 This is a face recognition framework based on PyTorch with convenient training, evaluation and feature extraction...
  • pytorch CNN特定人脸识别入门实战

    千次阅读 2022-04-09 23:03:57
    基于pytorch框架的卷积神经网络入门,用于特定人脸识别的分类训练(二分类)
  • 基于Pytorch实现的快速人脸识别模型

    千次阅读 热门讨论 2021-11-03 15:22:05
    本项目参考了ArcFace的损失函数结合MobileNet,意在开发一个模型较小,但识别准确率较高且推理速度快的一种人脸识别项目,该项目训练数据使用emore数据集,一共有85742个人,共5822653张图片,使用lfw-align-128数据...
  • pytorch 实现人脸检测与识别

    万次阅读 多人点赞 2021-05-21 21:18:42
    pytorch + opencv 实现人脸检测与识别 最近阅读了《Dive into Deep Learning》(动手学深度学习)这本书,根据所学的知识动手完成了人脸检测与识别。这篇博客主要是记录下自己在完成的过程中所用到的东西,以及遇到的...
  • 该实验通过PCA降维+BP神经网络的算法实现对人脸数据集中人脸数据的识别
  • 神经网络学习小记录55——Pytorch 搭建自己的facenet人脸识别平台学习前言什么是facenet源码下载facenet的实现思路一、预测部分1、主干网络介绍2、根据特征获得128维特征向量3、l2标准化二、训练部分1、数据集介绍2...
  • 中文翻译:从零开始搭建人脸识别系统(一)MTCNN - 知乎 1、网络结构 mtcnn 算法人脸检测过程分为三个独立的stage,每一个stage对应一个卷积网络,分别为pnet,rnet,onet。网络结构如图所示。 mtcnn三个网络的...
  • 基于Vue+Flask的PyTorch人脸匹配、识别、对齐的实现
  • pip install facenet_pytorch 验证数据库构造 先用mtcnn提取脸部图片 import cv2 from facenet_pytorch import MTCNN,InceptionResnetV1 resnet=InceptionResnetV1(pretrained='vggface2').eval() mtcnn = MTCNN...
  • 基于pytorch卷积人脸表情识别--毕业设计

    千次阅读 多人点赞 2021-07-13 09:20:23
    基于卷积神经网络的人脸表情识别前言毕业设计内容介绍卷积神经网络的设计卷积网络的模型卷积池化过程详细说明第一层卷积池化过程第二层卷积池化过程第三层卷积池化过程全连接层过程模型的训练过程卷积与池化原理模型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,794
精华内容 3,117
关键字:

pytorch人脸识别