【iOS干货】☞ 初认识 Socket 网络通信

人脸图像预处理。基于人脸检测结果,处理图像,服务特征提取。系统得到人脸图像被各种规范限制、随机干扰,需缩放、旋转、拉伸、光线补偿、灰度变换、直方图均衡化、规范化、几哪校正、过滤、锐化等图像预处理。

亚、网络通信的元素

  网络直达之请虽是通过Socket来树立连接然后相互通信

  1.
IP地址(网络直达主机设备的唯一标识)——>寻找服务器主机

  2. 端口号(定位程序) ——> 寻找程序

    • 用于标示进程的逻辑地址,不同进程的标示
    • 可行端口:0~65535,其中0~1024由网采取或封存端口,开发被建议利用1024以上之端口

  3.
传协议(就是之所以哪的点子进行互)

  • 报导的平整
  • 常见协议:TCP、UDP

人脸验证。分析两摆放人脸同一人可能大小。输入两摆设脸,得到置信度分类、相应阈值,评估相似度。

老三、传输协议 TCP/UDP

  TCP和UDP:数据传的片栽方法,即把数量由平端传至任何一样端的蝇头栽方式

  1.
TCP(传输控制协议)
—>要树连接(如:发送HTTP请求,客户端向服务端发送网络要)

☞ 建立连接,形成传输数据的通道

☞ 于连接着展开充分数目传(数据大小非受限制)

☞ 通过三不好握手完成连接,是牢靠协议,安全送达

        说明:在确立通信连接(打通管道)之前有三涂鸦握手,目的是为多少的安全性和可靠性(让数安全可靠的传至对方)。

        举例:打电话 (理解三次握手)

第一浅握手:拿起电话,进行拨号。这个拨号的长河叫第一赖握手。【开始准备连接】

仲不良握手:拨通了,对方”喂”了千篇一律名气(响应了扳平名气),我听见了,称为第二涂鸦握手。【说明我连而 没问题】

其三差握手:我听见了对方”喂”了平信誉(响应了一如既往名),我呢习惯性的”喂”了扳平望,对方听到了。【说明你总是我 没问题】

假使及时三个经过都不曾问题,就好确定通话连接起成。

    ☞ 必须树立连接,效率会略小。(每次要都要树连接)

  2.
UDP(用户数量报协议)—>不建连接 (如:广播用此,不断的发送数据包)

    ☞ 将 数据 及 源 和 目的 封装成数据包中,不欲树立连接

    ☞ 每个数据报的分寸限制在64KB之内

    ☞ 因为随便需连续,因此是不可靠协议

      举例:看师资广播讲课,网络卡主了,再瞅的凡时髦的视频内容,不能够跟着看,可能失去了有情节。

    ☞ 不需树立连接,速度快 (省掉了三浅握手操作)

for step in xrange(num_steps):
start_time = time.time()
_, loss_value = sess.run([train_op, total_loss])
duration = time.time() – start_time
assert not np.isnan(loss_value), ‘Model diverged with loss = NaN’
# 每10步记录一致糟摘要文件,保存一个检查点文件
if step % 10 == 0:
num_examples_per_step = FLAGS.batch_size
examples_per_sec = num_examples_per_step / duration
sec_per_batch = float(duration)

六、长连接和短连接

  长连接和短连接:是接连的一个封存状态(保存时),长连接就是加上时总是,短连接就是不够日连。

  • http网络要是紧缺连接。
  • 长连接用在即时通信(实时聊天,要随时随地的发送信息,考虑到性,用长连)

export PYTHONPATH=[…]/facenet/src

3. 【案例】体验Socket通信-群聊客户端实现

  

  

///  ViewController.m
#import "ViewController.h"
#import "GCDAsyncSocket.h"

@interface ViewController ()<UITableViewDataSource, GCDAsyncSocketDelegate>
@property (weak, nonatomic) IBOutlet UITableView *tableView;
@property (weak, nonatomic) IBOutlet UITextField *textField;
@property (nonatomic, strong) GCDAsyncSocket *clientSocket;

@property (nonatomic, strong) NSMutableArray *dataArr;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // 实现聊天室
    // 1. 连接到服务器
    NSError *error = nil;
    [self.clientSocket connectToHost:@"192.168.1.95" onPort:5288 error:&error];
    if (error) {
        NSLog(@"error:%@", error);
    }
}

#pragma mark - GCDAsyncSocketDelegate
- (void)socket:(GCDAsyncSocket *)clientSock didConnectToHost:(NSString *)host port:(uint16_t)port {
    NSLog(@"与服务器连接成功!");
    // 监听读取数据(在读数据的时候,要监听有没有数据可读,目的是保证数据读取到)
    [clientSock readDataWithTimeout:-1 tag:0];
}

- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)err {
    NSLog(@"与服务器断开连接:%@", err);
}

// 读取数据(接收消息)
- (void)socket:(GCDAsyncSocket *)clientSock didReadData:(NSData *)data withTag:(long)tag {
    NSString *messageStr = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
    NSLog(@"接收到消息:%@", messageStr);
    messageStr = [NSString stringWithFormat:@"【匿名】:%@", messageStr];
    [self.dataArr addObject:messageStr];
    // 刷新UI要在主线程
    dispatch_async(dispatch_get_main_queue(), ^{
        [self.tableView reloadData];
    });

    // 监听读取数据(读完数据后,继续监听有没有数据可读,目的是保证下一次数据可以读取到)
    [clientSock readDataWithTimeout:-1 tag:0];
}

#pragma mark - UITableViewDataSource
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    return 1;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return self.dataArr.count;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cell"];
    cell.textLabel.text = self.dataArr[indexPath.row];
    return cell;
}

- (IBAction)clickSenderBtn:(UIButton *)sender {
    NSLog(@"发送消息");
    [self.view endEditing:YES];
    NSString *senderStr = self.textField.text;
    if (senderStr.length == 0) {
        return;
    }
    // 发送数据
    [self.clientSocket writeData:[senderStr dataUsingEncoding:NSUTF8StringEncoding] withTimeout:-1 tag:0];

    senderStr = [NSString stringWithFormat:@"【我】:%@", senderStr];
    [self.dataArr addObject:senderStr];
    [self.tableView reloadData];
}

- (GCDAsyncSocket *)clientSocket {
    if (!_clientSocket) {
        _clientSocket = [[GCDAsyncSocket alloc]initWithDelegate:self delegateQueue:dispatch_get_global_queue(0, 0)];
    }
    return _clientSocket;
}

- (NSMutableArray *)dataArr {
    if (!_dataArr) {
        _dataArr = [[NSMutableArray alloc]init];
    }
    return _dataArr;
}

@end


体验Socket通信-群聊客户端实现:

Demo下载地址:https://github.com/borenfocus/SocketGroupClientDemo  

迎推荐上海机上工作时,我之微信:qingxingfengzi

一、概念

  • Socket 字面意思又如“套接字”

  • 网达到的片单次(如,客户端以及劳务器端)通过一个双向的通信连接实现多少的交换,这个连续的均等端称为一个Socket。

  • 应用程序一般是预先通过Socket来建立一个通信连接,再望网发出请求或响应网络要。

  

  说明:

    ☞ 客户端向服务器端发送网络要前,必须使事先以底部建立一个通信连接(通信管道),才会发送网络要。

客户端向劳动器端发送http请求,服务器返回数据,这个进程即是一个数据交换的过程。

客户端和劳务器端进行数据交换,需要事先成立一个双向的通信连接(即一律漫长线、一个大路)

    ☞ 客户端和劳务端
两端都有一个Socket,通过Socket建立一个连(双向通信管道),有了管道就得展开数量传。

    ☞ Socket 就是通信管道的鲜独端口,可以领略啊管道的进口/出口。

def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:

五、体验 Socket

  实现Socket服务端监听:

1)使用C语言实现。

2)使用 CocoaAsyncSocket 第三正在框架(OC),内部是对准C的包装。

    telnet命令:是连续服务器上的某部端口对应之劳务。

    telnet命令:telnet
host port 

      如:telnet www.baidu.com 80  (IP地址与域名一样,都能够找到主机。)

微软脸部图片识别性、年龄网站 http://how-old.net/
。图片识别年龄、性别。根据问题查找图片。

七、Socket 层上之说道

  Socket层及的商事:指的数传的格式。

  1. HTTP合计:定义在网达到数据传的同一种植格式。

    传输格式:假设:这是使,实际http的格式不是如此的。

    http1.1,content-type:multipart/form-data,content-length:188,body:username=zhangsan&password=123456

  2.
XMPP协议:是一模一样缓缓即时通讯协议 (别人定义好的情商,我们常常将来所以)

    是依据可扩大标记语言(XML)的说道,它用于即时消息(IM)以及在线现场探测。

    传输格式:

      <from>zhangsan<from>

      <to>lisi<to>

      <body>一起吃晚上</body>

  3.
于定义即时通讯协议,json格式。

    {

      ”from”:
“zhangsan”,

      ”to”:
“lisi”,

      ”body”:
“中午共同用餐”,

    }

  你开啊操作,必须使发出一个稳住的格式,这样服务器才亮您要是召开呀。

  

  举例:写一封闭信于北京知音(区别 TCP/UDP 与 HTTP/XMMP)

  • 数传的方:TCP/UDP —》相当给 EMS/顺丰/申通/中通   

  • 数量传的格式:HTTP/XMMP —》相当给 信的内容格式 (可以是华语/英文/…等)

 

人脸识别应用,美图秀秀美颜应用、世纪佳缘查看地下配偶“面相”相似度,支付领域“刷脸支付”,安防领域“人脸鉴权”。Face++、商汤科技,提供人脸识别SDK。

1. 【案例】写个10086劳务,体验客户端和服务端的Socket通信


自己写一个服务端,用极代替客户端来演示

☞ 掌握:通过Socket对象在服务器里怎么去接收数据和归数据。

/// ----- MyServiceListener.h -----
@interface MyServiceListener : NSObject
//开启服务
- (void)start;
@end

/// ----- MyServiceListener.m -----
#import "MyServiceListener.h"
#import "GCDAsyncSocket.h"
/**
 *  服务的监听者(服务端监听客户端连接)
 */
@interface MyServiceListener()<GCDAsyncSocketDelegate>
/** 保存服务端的Socket对象 */
@property (nonatomic, strong) GCDAsyncSocket *serviceSocket;
/** 保存客户端的所有Socket对象 */
@property (nonatomic, strong) NSMutableArray *clientSocketArr;

@end

@implementation MyServiceListener
- (GCDAsyncSocket *)serviceSocket {
    if (!_serviceSocket) {
        //1.创建一个Socket对象
                //serviceSocket 服务端的Socket只监听 有没有客户端请求连接
               //队列:代理的方法在哪个队列里调用 (子线程的队列)
        _serviceSocket = [[GCDAsyncSocket alloc]initWithDelegate:self delegateQueue:dispatch_get_global_queue(0, 0)];
    }
    return _serviceSocket;
}

- (NSMutableArray *)clientSocketArr {
    if(!_clientSocketArr) {
        _clientSocketArr = [NSMutableArray array];
    }
    return _clientSocketArr;
}

- (void)start {
    //开启10086服务:5288
    //2.绑定端口 + 开启监听
    NSError *error = nil;
    //框架里的这个方法做了两件事情:绑定端口和开启监听
    [self.serviceSocket acceptOnPort:5288 error:&error];
    if (!error) {
        NSLog(@"10086服务开启成功!");
    } else {
        //失败的原因是端口被其它程序占用
        NSLog(@"10086服务开启失败:%@", error);
    }    
}

#pragma mark -- 实现代理的方法 如果有客户端的Socket连接到服务器,就会调用这个方法。
- (void)socket:(GCDAsyncSocket *)serviceSocket didAcceptNewSocket:(GCDAsyncSocket *)clientSocket {
    static NSInteger index = 1;
    NSLog(@"客户端【%ld】已连接到服务器!", index++);
    //1.保存客户端的Socket(客户端的Socket被释放了,连接就会关闭)
    [self.clientSockets addObject:clientSocket];

    //提供服务(客户端一连接到服务器,就打印下面的内容)
    NSMutableString *serviceStr = [[NSMutableString alloc]init];
    [serviceStr appendString:@"========欢迎来到10086在线服务========\n"];
    [serviceStr appendString:@"请输入下面的数字选择服务...\n"];
    [serviceStr appendString:@" [0] 在线充值\n"];
    [serviceStr appendString:@" [1] 在线投诉\n"];
    [serviceStr appendString:@" [2] 优惠信息\n"];
    [serviceStr appendString:@" [3] special services\n"];
    [serviceStr appendString:@" [4] 退出\n"];
    [serviceStr appendString:@"=====================================\n"];
    // 服务端给客户端发送数据
    [clientSocket writeData:[serviceStr dataUsingEncoding:NSUTF8StringEncoding] withTimeout:-1 tag:0];

    //2.监听客户端有没有数据上传 (参数1:超时时间,-1代表不超时)
    /**
     *  timeout: 超时时间,-1 代表不超时
     *  tag:标识作用,现在不用就写0
     */
    [clientSocket readDataWithTimeout:-1 tag:0];
}

#pragma mark -- 服务器端 读取 客户端请求(发送)的数据。在服务端接收客户端数据,这个方法会被调用
- (void)socket:(GCDAsyncSocket *)clientSocket didReadData:(NSData *)data withTag:(long)tag {
    //1.获取客户端发送的数据
    NSString *str = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
    NSInteger index = [self.clientSocketArr indexOfObject:clientSocket];
    NSLog(@"接收到客户端【%ld】发送的数据:%@", index + 1, str);
    //把字符串转成数字
    NSInteger num = [str integerValue];
    NSString *responseStr = nil;
    //服务器对应的处理的结果
    switch (num) {
        case 0:
            responseStr = @"在线充值服务暂停中...\n";
            break;
        case 1:
            responseStr = @"在线投诉服务暂停中...\n";
            break;
        case 2:
            responseStr = @"优惠信息没有\n";
            break;
        case 3:
            responseStr = @"没有特殊服务\n";
            break;
        case 4:
            responseStr = @"恭喜你退出成功!\n";
            break;
        default:
            break;
    }

    //2.服务端处理请求,返回数据(data)给客户端
    [clientSocket writeData:[responseStr dataUsingEncoding:NSUTF8StringEncoding] withTimeout:-1 tag:0];
    //写完数据后 判断
    if (num == 4) {
        //移除客户端,就会关闭连接
        [self.clientSockets removeObject:clientSocket];
    }

    //由于框架内部的实现,每次读完数据后,都要调用一次监听数据的方法(保证能接收到客户端第二次上传的数据)
    [clientSocket readDataWithTimeout:-1 tag:0];

}
@end

/// ----- ViewController.m -----
#import "ViewController.h"
#import "MyServiceListener.h"
@interface ViewController ()

@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    //1.创建一个服务监听对象
    MyServiceListener *listener = [[MyServiceListener alloc]init];
    //2.开始监听
    [listener start];
    //3.开启主运行循环,让服务不能停(服务器一般要永久开启)
    [[NSRunLoop mainRunLoop] run];

}
@end


体验Socket通信-服务端简单实现代码:

Demo下载地址:https://github.com/borenfocus/Socket10086ServerDemo 

 

weights = tf.Variable(tf.random_normal([512, nlabels], mean=0.0,
stddev=0.01), name=’weights’)
biases = tf.Variable(tf.constant(0.0, shape=[nlabels],
dtype=tf.float32), name=’biases’)
output = tf.add(tf.matmul(drop2, weights), biases, name=scope.name)
return output

季、Socket 通信流程图

☞ bind():绑定端口 (80、3306)

☞ listen():监听端口(服务器监听客户端起没有产生连日至者端口来)

☞ accept():如果有连日到此端口,就接受这连续。(通信管道挖,接下便得传输数据了)

☞ write():发请求/写请求/发数据

☞ read():读请求/读数据

  • HTTP底层就是Socket通信,通过Socket建立连接(通信管道),实现多少传,连接的法(数据传的道)是TCP。
  • HTTP是一个TCP的传导协议(方式),它是一个可靠、安全之商事。

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from datetime import datetime
import math
import time
from data import inputs
import numpy as np
import tensorflow as tf
from model import select_model, get_checkpoint
from utils import *
import os
import json
import csv
RESIZE_FINAL = 227
GENDER_LIST =[‘M’,’F’]
AGE_LIST = [‘(0, 2)’,'(4, 6)’,'(8, 12)’,'(15, 20)’,'(25, 32)’,'(38,
43)’,'(48, 53)’,'(60, 100)’]
MAX_BATCH_SZ = 128
tf.app.flags.DEFINE_string(‘model_dir’, ”,
‘Model directory (where training data lives)’)
tf.app.flags.DEFINE_string(‘class_type’, ‘age’,
‘Classification type (age|gender)’)
tf.app.flags.DEFINE_string(‘device_id’, ‘/cpu:0’,
‘What processing unit to execute inference on’)
tf.app.flags.DEFINE_string(‘filename’, ”,
‘File (Image) or File list (Text/No header TSV) to process’)
tf.app.flags.DEFINE_string(‘target’, ”,
‘CSV file containing the filename processed along with best guess and
score’)
tf.app.flags.DEFINE_string(‘checkpoint’, ‘checkpoint’,
‘Checkpoint basename’)
tf.app.flags.DEFINE_string(‘model_type’, ‘default’,
‘Type of convnet’)
tf.app.flags.DEFINE_string(‘requested_step’, ”, ‘Within the model
directory, a requested step to restore e.g., 9000’)
tf.app.flags.DEFINE_boolean(‘single_look’, False, ‘single look at the
image or multiple crops’)
tf.app.flags.DEFINE_string(‘face_detection_model’, ”, ‘Do frontal
face detection with model specified’)
tf.app.flags.DEFINE_string(‘face_detection_type’, ‘cascade’, ‘Face
detection model type (yolo_tiny|cascade)’)
FLAGS = tf.app.flags.FLAGS
def one_of(fname, types):
return any([fname.endswith(‘.’ + ty) for ty in types])
def resolve_file(fname):
if os.path.exists(fname): return fname
for suffix in (‘.jpg’, ‘.png’, ‘.JPG’, ‘.PNG’, ‘.jpeg’):
cand = fname + suffix
if os.path.exists(cand):
return cand
return None
def classify_many_single_crop(sess, label_list, softmax_output,
coder, images, image_files, writer):
try:
num_batches = math.ceil(len(image_files) / MAX_BATCH_SZ)
pg = ProgressBar(num_batches)
for j in range(num_batches):
start_offset = j * MAX_BATCH_SZ
end_offset = min((j + 1) * MAX_BATCH_SZ, len(image_files))

2. 【案例扩展】写个换车信息服务(群聊服务端)

  • 大抵个客户端连接到服务器。
  • 当一个客户端发送信息于服务器时,服务器转发给任何都连续的客户端。
  • 相当给一个群聊的雏形。

  

/// MyService.h
#import <Foundation/Foundation.h>

@interface MyService : NSObject
/** 开启服务 */
- (void)startService;

@end

/// MyService.m
#import "MyService.h"
#import "GCDAsyncSocket.h"

@interface MyService ()<GCDAsyncSocketDelegate>
/** 保存服务端的Socket对象 */
@property (nonatomic, strong) GCDAsyncSocket *serviceSocket;
/** 保存客户端的所有Socket对象 */
@property (nonatomic, strong) NSMutableArray *clientSocketArr;

@end

@implementation MyService

//开启10086服务:5288
- (void)startService {
    NSError *error = nil;
    // 绑定端口 + 开启监听
    [self.serviceSocket acceptOnPort:5288 error:&error];
    if (!error) {
        NSLog(@"服务开启成功!");
    } else {
        NSLog(@"服务开启失败!");
    }
}

#pragma mark -- 实现代理的方法 如果有客户端的Socket连接到服务器,就会调用这个方法。
- (void)socket:(GCDAsyncSocket *)serviceSocket didAcceptNewSocket:(GCDAsyncSocket *)clientSocket {
    // 客户端的端口号是系统分配的,服务端的端口号是我们自己分配的
    NSLog(@"客户端【Host:%@, Port:%d】已连接到服务器!", clientSocket.connectedHost, clientSocket.connectedPort);
    //1.保存客户端的Socket(客户端的Socket被释放了,连接就会关闭)
    [self.clientSocketArr addObject:clientSocket];

    //2.监听客户端有没有数据上传 (参数1:超时时间,-1代表不超时;参数2:标识作用,现在不用就写0)
    [clientSocket readDataWithTimeout:-1 tag:0];
}

#pragma mark -- 服务器端 读取 客户端请求(发送)的数据。在服务端接收客户端数据,这个方法会被调用
- (void)socket:(GCDAsyncSocket *)clientSocket didReadData:(NSData *)data withTag:(long)tag {
    //1.获取客户端发送的数据
    NSString *messageStr = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
    NSLog(@"接收到客户端【Host:%@, Port:%d】发送的数据:%@",  clientSocket.connectedHost, clientSocket.connectedPort, messageStr);
    // 遍历客户端数组
    for (GCDAsyncSocket *socket in self.clientSocketArr) {
        if (socket != clientSocket) { // 不转发给自己
            //2.服务端把收到的消息转发给其它客户端
            [socket writeData:data withTimeout:-1 tag:0];
        }
    }
    //由于框架内部的实现,每次读完数据后,都要调用一次监听数据的方法(保证能接收到客户端第二次上传的数据)
    [clientSocket readDataWithTimeout:-1 tag:0];
}

- (GCDAsyncSocket *)serviceSocket {
    if (!_serviceSocket) {
        // 1.创建一个Socket对象
        // serviceSocket 服务端的Socket只监听 有没有客户端请求连接
        // 队列:代理的方法在哪个队列里调用 (子线程的队列)
        _serviceSocket = [[GCDAsyncSocket alloc]initWithDelegate:self delegateQueue:dispatch_get_global_queue(0, 0)];
    }
    return _serviceSocket;
}

- (NSMutableArray *)clientSocketArr {
    if (!_clientSocketArr) {
        _clientSocketArr = [[NSMutableArray alloc]init];
    }
    return _clientSocketArr;
}

@end


/// main.m
#import <Foundation/Foundation.h>
#import "MyService.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //1.创建一个服务监听对象
        MyService *service = [[MyService alloc]init];
        //2.开始监听
        [service startService];
        //3.开启主运行循环,让服务不能停(服务器一般要永久开启)
        [[NSRunLoop mainRunLoop] run];
    }
    return 0;
}


体验Socket通信-群聊服务端实现代码:

 Demo下载地址:https://github.com/borenfocus/SocketGroupServerDemo

weights = tf.Variable(tf.truncated_normal([2048, nlabels], mean=0.0,
stddev=0.01), name=’weights’)
biases = tf.Variable(tf.constant(0.0, shape=[nlabels],
dtype=tf.float32), name=’biases’)
output = tf.add(tf.matmul(net, weights), biases, name=scope.name)
_activation_summary(output)
return output
def levi_hassner_bn(nlabels, images, pkeep, is_training):
batch_norm_params = {
“is_training”: is_training,
“trainable”: True,
# Decay for the moving averages.
“decay”: 0.9997,
# Epsilon to prevent 0s in variance.
“epsilon”: 0.001,
# Collection containing the moving mean and moving variance.
“variables_collections”: {
“beta”: None,
“gamma”: None,
“moving_mean”: [“moving_vars”],
“moving_variance”: [“moving_vars”],
}
}
weight_decay = 0.0005
weights_regularizer =
tf.contrib.layers.l2_regularizer(weight_decay)
with tf.variable_scope(“LeviHassnerBN”, “LeviHassnerBN”, [images]) as
scope:
with tf.contrib.slim.arg_scope(
[convolution2d, fully_connected],
weights_regularizer=weights_regularizer,
biases_initializer=tf.constant_initializer(1.),
weights_initializer=tf.random_normal_initializer(stddev=0.005),
trainable=True):
with tf.contrib.slim.arg_scope(
[convolution2d],
weights_initializer=tf.random_normal_initializer(stddev=0.01),
normalizer_fn=batch_norm,
normalizer_params=batch_norm_params):
conv1 = convolution2d(images, 96, [7,7], [4, 4], padding=’VALID’,
biases_initializer=tf.constant_initializer(0.), scope=’conv1′)
pool1 = max_pool2d(conv1, 3, 2, padding=’VALID’, scope=’pool1′)
conv2 = convolution2d(pool1, 256, [5, 5], [1, 1], padding=’SAME’,
scope=’conv2′)
pool2 = max_pool2d(conv2, 3, 2, padding=’VALID’, scope=’pool2′)
conv3 = convolution2d(pool2, 384, [3, 3], [1, 1], padding=’SAME’,
biases_initializer=tf.constant_initializer(0.), scope=’conv3′)
pool3 = max_pool2d(conv3, 3, 2, padding=’VALID’, scope=’pool3′)
# can use tf.contrib.layer.flatten
flat = tf.reshape(pool3, [-1, 384*6*6], name=’reshape’)
full1 = fully_connected(flat, 512, scope=’full1′)
drop1 = tf.nn.dropout(full1, pkeep, name=’drop1′)
full2 = fully_connected(drop1, 512, scope=’full2′)
drop2 = tf.nn.dropout(full2, pkeep, name=’drop2′)
with tf.variable_scope(‘output’) as scope:

softmax_output = tf.nn.softmax(logits)
coder = ImageCoder()
# Support a batch mode if no face detection model
if len(files) == 0:
if (os.path.isdir(FLAGS.filename)):
for relpath in os.listdir(FLAGS.filename):
abspath = os.path.join(FLAGS.filename, relpath)

# Get input and output tensors
# 获取输入输出张量
images_placeholder =
tf.get_default_graph().get_tensor_by_name(“input:0”)
embeddings =
tf.get_default_graph().get_tensor_by_name(“embeddings:0”)
phase_train_placeholder =
tf.get_default_graph().get_tensor_by_name(“phase_train:0”)

# 4. 盘算准确率、验证率,十折交叉验证办法
tpr, fpr, accuracy, val, val_std, far = lfw.evaluate(emb_array,
actual_issame, nrof_folds=args.lfw_nrof_folds)
print(‘Accuracy: %1.3f+-%1.3f’ % (np.mean(accuracy),
np.std(accuracy)))
print(‘Validation rate: %2.5f+-%2.5f @ FAR=%2.5f’ % (val, val_std,
far))
# 得到auc值
auc = metrics.auc(fpr, tpr)
print(‘Area Under Curve (AUC): %1.3f’ % auc)
# 1得到错误率(eer)
eer = brentq(lambda x: 1. – x – interpolate.interp1d(fpr, tpr)(x), 0.,
1.)
print(‘Equal Error Rate (EER): %1.3f’ % eer)

Florian Schroff、Dmitry Kalenichenko、James Philbin论文《FaceNet: A
Unified Embedding for Face Recognition and Clustering》
https://arxiv.org/abs/1503.03832
。https://github.com/davidsandberg/facenet/wiki/Validate-on-lfw 。

人脸识别优势,非强制性(采集方式不轻受察觉,被认识别人脸图像而积极赢得)、非接触性(用户不待与设备接触)、并发性(可同时多口脸检测、跟踪、识别)。深度上前,人脸识别两手续:高维人工特征提取、降维。传统人脸识别技术基于可见光图像。深度上+大数额(海量有号人脸数据)为人脸识别领域主流技术路线。神经网络人脸识别技术,大量样本图像训练识别模型,无需人工选取特征,样本训练过程自行学习,识别准确率可以直达99%。

nlabels = len(label_list)
if nlabels > 2:
output[best] = 0
second_best = np.argmax(output)
print(‘Guess @ 2 %s, prob = %.2f’ % (label_list[second_best],
output[second_best]))
if writer is not None:
writer.writerow((image_file, best_choice[0], ‘%.2f’ %
best_choice[1]))
except Exception as e:
print(e)
print(‘Failed to run image %s ‘ % image_file)
def list_images(srcfile):
with open(srcfile, ‘r’) as csvfile:
delim = ‘,’ if srcfile.endswith(‘.csv’) else ‘\t’
reader = csv.reader(csvfile, delimiter=delim)
if srcfile.endswith(‘.csv’) or srcfile.endswith(‘.tsv’):
print(‘skipping header’)
_ = next(reader)

人数脸检测。检测、定位图片人脸,返回高业饿呀总人口脸框坐标。对人口脸分析、处理的第一步。“滑动窗口”,选择图像矩形区域作滑动窗口,窗口中提特征对图像区域描述,根据特征描述判断窗口是否人脸。不断遍历需要着眼窗口。

requested_step = FLAGS.requested_step if FLAGS.requested_step else
None

batch_image_files = image_files[start_offset:end_offset]
print(start_offset, end_offset, len(batch_image_files))
image_batch = make_multi_image_batch(batch_image_files, coder)
batch_results = sess.run(softmax_output,
feed_dict={images:image_batch.eval()})
batch_sz = batch_results.shape[0]
for i in range(batch_sz):
output_i = batch_results[i]
best_i = np.argmax(output_i)
best_choice = (label_list[best_i], output_i[best_i])
print(‘Guess @ 1 %s, prob = %.2f’ % best_choice)
if writer is not None:
f = batch_image_files[i]
writer.writerow((f, best_choice[0], ‘%.2f’ % best_choice[1]))
pg.update()
pg.done()
except Exception as e:
print(e)
print(‘Failed to run all images’)
def classify_one_multi_crop(sess, label_list, softmax_output,
coder, images, image_file, writer):
try:
print(‘Running file %s’ % image_file)
image_batch = make_multi_crop_batch(image_file, coder)
batch_results = sess.run(softmax_output,
feed_dict={images:image_batch.eval()})
output = batch_results[0]
batch_sz = batch_results.shape[0]

数码预处理。脚本把多少处理成TFRecords格式。https://github.com/dpressel/rude-carnie/blob/master/preproc.py
。https://github.com/GilLevi/AgeGenderDeepLearning/tree/master/Folds文件夹,已经对训练集、测试集划分、标注。gender\_train.txt、gender\_val.txt
图片列表 Adience 数据集处理TFRecords文件。图片处理吧大小256×256
JPEG编码RGB图像。tf.python_io.TFRecordWriter写副TFRecords文件,输出文件output_file。

weights = tf.Variable(tf.random_normal([512, nlabels], mean=0.0,
stddev=0.01), name=’weights’)
biases = tf.Variable(tf.constant(0.0, shape=[nlabels],
dtype=tf.float32), name=’biases’)
output = tf.add(tf.matmul(drop2, weights), biases, name=scope.name)
return output
def levi_hassner(nlabels, images, pkeep, is_training):
weight_decay = 0.0005
weights_regularizer =
tf.contrib.layers.l2_regularizer(weight_decay)
with tf.variable_scope(“LeviHassner”, “LeviHassner”, [images]) as
scope:
with tf.contrib.slim.arg_scope(
[convolution2d, fully_connected],
weights_regularizer=weights_regularizer,
biases_initializer=tf.constant_initializer(1.),
weights_initializer=tf.random_normal_initializer(stddev=0.005),
trainable=True):
with tf.contrib.slim.arg_scope(
[convolution2d],
weights_initializer=tf.random_normal_initializer(stddev=0.01)):
conv1 = convolution2d(images, 96, [7,7], [4, 4], padding=’VALID’,
biases_initializer=tf.constant_initializer(0.), scope=’conv1′)
pool1 = max_pool2d(conv1, 3, 2, padding=’VALID’, scope=’pool1′)
norm1 = tf.nn.local_response_normalization(pool1, 5, alpha=0.0001,
beta=0.75, name=’norm1′)
conv2 = convolution2d(norm1, 256, [5, 5], [1, 1], padding=’SAME’,
scope=’conv2′)
pool2 = max_pool2d(conv2, 3, 2, padding=’VALID’, scope=’pool2′)
norm2 = tf.nn.local_response_normalization(pool2, 5, alpha=0.0001,
beta=0.75, name=’norm2′)
conv3 = convolution2d(norm2, 384, [3, 3], [1, 1],
biases_initializer=tf.constant_initializer(0.), padding=’SAME’,
scope=’conv3′)
pool3 = max_pool2d(conv3, 3, 2, padding=’VALID’, scope=’pool3′)
flat = tf.reshape(pool3, [-1, 384*6*6], name=’reshape’)
full1 = fully_connected(flat, 512, scope=’full1′)
drop1 = tf.nn.dropout(full1, pkeep, name=’drop1′)
full2 = fully_connected(drop1, 512, scope=’full2′)
drop2 = tf.nn.dropout(full2, pkeep, name=’drop2′)
with tf.variable_scope(‘output’) as scope:

with tf.variable_scope(‘output’) as scope:

# Read the file containing the pairs used for testing
# 1. 读入之前的pairs.txt文件
# 读入后如[[‘Abel_Pacheco’,’1′,’4′]]
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
# 获取文件路径和是否匹配关系对
paths, actual_issame =
lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs,
args.lfw_file_ext)
# Load the model
# 2. 加载模型
facenet.load_model(args.model)

#image_size = images_placeholder.get_shape()[1] # For some reason
this doesn’t work for frozen graphs
image_size = args.image_size
embedding_size = embeddings.get_shape()[1]

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from datetime import datetime
import time
import os
import numpy as np
import tensorflow as tf
from data import distorted_inputs
import re
from tensorflow.contrib.layers import *
from tensorflow.contrib.slim.python.slim.nets.inception_v3 import
inception_v3_base
TOWER_NAME = ‘tower’
def select_model(name):
if name.startswith(‘inception’):
print(‘selected (fine-tuning) inception model’)
return inception_v3
elif name == ‘bn’:
print(‘selected batch norm model’)
return levi_hassner_bn
print(‘selected default model’)
return levi_hassner
def get_checkpoint(checkpoint_path, requested_step=None,
basename=’checkpoint’):
if requested_step is not None:
model_checkpoint_path = ‘%s/%s-%s’ % (checkpoint_path, basename,
requested_step)
if os.path.exists(model_checkpoint_path) is None:
print(‘No checkpoint file found at [%s]’ % checkpoint_path)
exit(-1)
print(model_checkpoint_path)
print(model_checkpoint_path)
return model_checkpoint_path, requested_step
ckpt = tf.train.get_checkpoint_state(checkpoint_path)
if ckpt and ckpt.model_checkpoint_path:
# Restore checkpoint as described in top of this program
print(ckpt.model_checkpoint_path)
global_step =
ckpt.model_checkpoint_path.split(‘/’)[-1].split(‘-‘)[-1]
return ckpt.model_checkpoint_path, global_step
else:
print(‘No checkpoint file found at [%s]’ % checkpoint_path)
exit(-1)
def _activation_summary(x):
tensor_name = re.sub(‘%s_[0-9]*/’ % TOWER_NAME, ”, x.op.name)
tf.summary.histogram(tensor_name + ‘/activations’, x)
tf.summary.scalar(tensor_name + ‘/sparsity’, tf.nn.zero_fraction(x))
def inception_v3(nlabels, images, pkeep, is_training):
batch_norm_params = {
“is_training”: is_training,
“trainable”: True,
# Decay for the moving averages.
“decay”: 0.9997,
# Epsilon to prevent 0s in variance.
“epsilon”: 0.001,
# Collection containing the moving mean and moving variance.
“variables_collections”: {
“beta”: None,
“gamma”: None,
“moving_mean”: [“moving_vars”],
“moving_variance”: [“moving_vars”],
}
}
weight_decay = 0.00004
stddev=0.1
weights_regularizer =
tf.contrib.layers.l2_regularizer(weight_decay)
with tf.variable_scope(“InceptionV3”, “InceptionV3”, [images]) as
scope:
with tf.contrib.slim.arg_scope(
[tf.contrib.slim.conv2d, tf.contrib.slim.fully_connected],
weights_regularizer=weights_regularizer,
trainable=True):
with tf.contrib.slim.arg_scope(
[tf.contrib.slim.conv2d],
weights_initializer=tf.truncated_normal_initializer(stddev=stddev),
activation_fn=tf.nn.relu,
normalizer_fn=batch_norm,
normalizer_params=batch_norm_params):
net, end_points = inception_v3_base(images, scope=scope)
with tf.variable_scope(“logits”):
shape = net.get_shape()
net = avg_pool2d(net, shape[1:3], padding=”VALID”, scope=”pool”)
net = tf.nn.dropout(net, pkeep, name=’droplast’)
net = flatten(net, scope=”flatten”)

if os.path.isfile(abspath) and any([abspath.endswith(‘.’ + ty) for ty
in (‘jpg’, ‘png’, ‘JPG’, ‘PNG’, ‘jpeg’)]):
print(abspath)
files.append(abspath)
else:
files.append(FLAGS.filename)
# If it happens to be a list file, read the list and clobber the
files
if any([FLAGS.filename.endswith(‘.’ + ty) for ty in (‘csv’, ‘tsv’,
‘txt’)]):
files = list_images(FLAGS.filename)

丁脸图像匹配、识别。提取人脸图像特点数据和数据库存储人脸特征模板搜索匹配,根据相似程度对身份信息进行判断,设定阈值,相似度越过阈值,输出匹配结果。确认,一对一(1:1)图像于,证明“你虽是你”,金融核实身份、信息安全领域。辨认,一针对性大多(1:N)图像匹配,“N人中搜索你”,视频流,人走上前识别范围就完了辨认,安防领域。

output /= batch_sz
best = np.argmax(output) # 最可能性能分类
best_choice = (label_list[best], output[best])
print(‘Guess @ 1 %s, prob = %.2f’ % best_choice)

writer = None
output = None
if FLAGS.target:
print(‘Creating output file %s’ % FLAGS.target)
output = open(FLAGS.target, ‘w’)
writer = csv.writer(output)
writer.writerow((‘file’, ‘label’, ‘score’))
image_files = list(filter(lambda x: x is not None, [resolve_file(f)
for f in files]))
print(image_files)
if FLAGS.single_look:
classify_many_single_crop(sess, label_list, softmax_output, coder,
images, image_files, writer)
else:
for image_file in image_files:
classify_one_multi_crop(sess, label_list, softmax_output, coder,
images, image_file, writer)
if output is not None:
output.close()

人脸识别分类。

return [row[0] for row in reader]
def main(argv=None): # pylint: disable=unused-argument
files = []

检测。python src/validate_on_lfw.py datasets/lfw/lfw_mtcnnpy_160
models
格比较,采用facenet/data/pairs.txt,官方随机大成数据,匹配同非配合配人名和图纸编号。

征模型。https://github.com/dpressel/rude-carnie/blob/master/guess.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
import numpy as np
import argparse
import facenet
import lfw
import os
import sys
import math
from sklearn import metrics
from scipy.optimize import brentq
from scipy import interpolate

if FLAGS.face_detection_model:
print(‘Using face detector (%s) %s’ % (FLAGS.face_detection_type,
FLAGS.face_detection_model))
face_detect = face_detection_model(FLAGS.face_detection_type,
FLAGS.face_detection_model)
face_files, rectangles = face_detect.run(FLAGS.filename)
print(face_files)
files += face_files
config = tf.ConfigProto(allow_soft_placement=True)
with tf.Session(config=config) as sess:
label_list = AGE_LIST if FLAGS.class_type == ‘age’ else
GENDER_LIST
nlabels = len(label_list)
print(‘Executing on %s’ % FLAGS.device_id)
model_fn = select_model(FLAGS.model_type)
with tf.device(FLAGS.device_id):

人脸图像特征提取。人脸图像信息数字化,人脸图像转变也同样拧数字(特征向量)。如,眼睛左边、嘴唇右边、鼻子、下附上位置,特征点间欧氏距离、曲率、角度提取出特色分量,相关特征连接成长特征向量。

人脸属性检测。人脸属性辩识、人脸情绪分析。https://www.betaface.com/wpa/
在线人脸识别测试。给出人年龄、是否来胡子、情绪(高兴、正常、生气、愤怒)、性别、是否带来眼镜、肤色。

预训练模型20170216-091149.zip
https://drive.google.com/file/d/0B5MzpY9kBtDVZ2RpVDYwWmxoSUk 。
训练集 MS-Celeb-1M数据集

MS-Celeb-1M: Challenge of Recognizing One Million Celebrities in the Real World


。微软人脸识别数据库,名人榜选择面前100万政要,搜索引擎采集每个名人100布置人脸图片。预训练模型准确率0.993+-0.004。

人脸识别技术流程。

saver = tf.train.Saver()
saver.restore(sess, model_checkpoint_path)

口脸检测。https://github.com/davidsandberg/facenet 。

校命令

for N in {1..4}; do python src/align/align_dataset_mtcnn.py
~/datasets/lfw/raw ~/datasets/lfw/lfw_mtcnnpy_160 –image_size 160
–margin 32 –random_order –gpu_memory_fraction 0.25 & done

十折交叉验证(10-fold cross
validation),精度测试方法。数据集分成10份,轮流将里面9卖做训练集,1客做测试保,10不成结果都值作算法精度估计。一般需频繁10赔交叉验证求均值。

人脸识别,基于人脸部特征信息识别身份的生物体识别技术。摄像机、摄像头采集人脸图像或看频流,自动检测、跟踪图像被脸部,做脸部相关技术处理,人脸检测、人脸要点检测、人脸验证等。《麻省理工科技评价》(MIT
Technology
Review),2017年环球十生突破性技术榜单,支付宝“刷脸支付”(Paying with Your
Face)入围。

parser.add_argument(‘lfw_dir’, type=str,
help=’Path to the data directory containing aligned LFW face
patches.’)
parser.add_argument(‘–lfw_batch_size’, type=int,
help=’Number of images to process in a batch in the LFW test set.’,
default=100)
parser.add_argument(‘model’, type=str,
help=’Could be either a directory containing the meta_file and
ckpt_file or a model protobuf (.pb) file’)
parser.add_argument(‘–image_size’, type=int,
help=’Image size (height, width) in pixels.’, default=160)
parser.add_argument(‘–lfw_pairs’, type=str,
help=’The file containing the pairs to use for validation.’,
default=’data/pairs.txt’)
parser.add_argument(‘–lfw_file_ext’, type=str,
help=’The file extension for the LFW dataset.’, default=’png’,
choices=[‘jpg’, ‘png’])
parser.add_argument(‘–lfw_nrof_folds’, type=int,
help=’Number of folds to use for cross validation. Mainly used for
testing.’, default=10)
return parser.parse_args(argv)
if __name__ == ‘__main__’:
main(parse_arguments(sys.argv[1:]))

format_str = (‘%s: step %d, loss = %.3f (%.1f examples/sec; %.3f ‘
‘sec/batch)’)
print(format_str % (datetime.now(), step, loss_value,
examples_per_sec, sec_per_batch))
# Loss only actually evaluated every 100 steps?
if step % 100 == 0:
summary_str = sess.run(summary_op)
summary_writer.add_summary(summary_str, step)

口脸图像采集、检测。人脸图像采集,摄像头将人脸图像采集下来,静态图像、动态图像、不同职务、不同表情。用户在收集设备拍报范围外,采集设置自动寻并拍照。人脸检测属于目标检测(object
detection)。对要检测对象靶概率统计,得到需要检测对象特征,建立目标检测模型。用模子匹配输入图像,输出匹配区域。人脸检测是人脸识别预处理,准确标定人脸在图像的职位大小。人脸图像模式特点丰富,直方图特征、颜色特征、模板特征、结构特征、哈尔特色(Haar-like
feature)。人脸检测挑来有因此信息,用特色检测脸部。人脸检测算法,模板匹配模型、Adaboost模型,Adaboost模型速度。精度综合性能最好,训练慢、检测快,可达到视频流实时检测效果。

构建模型。年龄、性别训练模型,Gil Levi、Tal Hassner论文《Age and Gender
Classification Using Convolutional Neural
Networks》http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.722.9654&rank=1
。模型 https://github.com/dpressel/rude-carnie/blob/master/model.py
。tenforflow.contrib.slim。

丁脸要点检测。定位、返回人脸五官、轮廓关键点坐标位置。人脸轮廓、眼睛、眉毛、嘴唇、鼻子轮廓。Face++提供高臻106沾要点。人脸要点铁定技术,级联形回归(cascaded
shape regression,
CSR)。人脸识别,基于DeepID网络布局。DeepID网络布局类似卷积神经网络结构,倒数第二层,有DeepID层,与卷积层4、最特别池化层3相连,卷积神经网络层数越高视野域越老,既考虑部分特征,又考虑全局特征。输入层
31x39x1、卷积层1 28x36x20(卷积核4x4x1)、最酷池化层1
12x18x20(过滤器2×2)、卷积层2 12x16x20(卷积核3x3x20)、最充分池化层2
6x8x40(过滤器2×2)、卷积层3 4x6x60(卷积核3x3x40)、最老池化层2
2x3x60(过滤器2×2)、卷积层4 2x2x80(卷积核2x2x60)、DeepID层
1×160、全连接层 Softmax。《Deep Learning Face Representation from
Predicting 10000 Classes》
http://mmlab.ie.cuhk.edu.hk/pdf/YiSun\_CVPR14.pdf 。

images = tf.placeholder(tf.float32, [None, RESIZE_FINAL,
RESIZE_FINAL, 3])
logits = model_fn(nlabels, images, 1, False)
init = tf.global_variables_initializer()

checkpoint_path = ‘%s’ % (FLAGS.model_dir)
model_checkpoint_path, global_step =
get_checkpoint(checkpoint_path, requested_step, FLAGS.checkpoint)

性别、年龄识别。https://github.com/dpressel/rude-carnie 。

数预处理。校准代码
https://github.com/davidsandberg/facenet/blob/master/src/align/align\_dataset\_mtcnn.py

检测所用数据集校准为和预训练模型所用多少集大小一样。
安环境变量

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from six.moves import xrange
from datetime import datetime
import time
import os
import numpy as np
import tensorflow as tf
from data import distorted_inputs
from model import select_model
import json
import re
LAMBDA = 0.01
MOM = 0.9
tf.app.flags.DEFINE_string(‘pre_checkpoint_path’, ”,
“””If specified, restore this pretrained model “””
“””before beginning any training.”””)
tf.app.flags.DEFINE_string(‘train_dir’,
‘/home/dpressel/dev/work/AgeGenderDeepLearning/Folds/tf/test_fold_is_0’,
‘Training directory’)
tf.app.flags.DEFINE_boolean(‘log_device_placement’, False,
“””Whether to log device placement.”””)
tf.app.flags.DEFINE_integer(‘num_preprocess_threads’, 4,
‘Number of preprocessing threads’)
tf.app.flags.DEFINE_string(‘optim’, ‘Momentum’,
‘Optimizer’)
tf.app.flags.DEFINE_integer(‘image_size’, 227,
‘Image size’)
tf.app.flags.DEFINE_float(‘eta’, 0.01,
‘Learning rate’)
tf.app.flags.DEFINE_float(‘pdrop’, 0.,
‘Dropout probability’)
tf.app.flags.DEFINE_integer(‘max_steps’, 40000,
‘Number of iterations’)
tf.app.flags.DEFINE_integer(‘steps_per_decay’, 10000,
‘Number of steps before learning rate decay’)
tf.app.flags.DEFINE_float(‘eta_decay_rate’, 0.1,
‘Learning rate decay’)
tf.app.flags.DEFINE_integer(‘epochs’, -1,
‘Number of epochs’)
tf.app.flags.DEFINE_integer(‘batch_size’, 128,
‘Batch size’)
tf.app.flags.DEFINE_string(‘checkpoint’, ‘checkpoint’,
‘Checkpoint name’)
tf.app.flags.DEFINE_string(‘model_type’, ‘default’,
‘Type of convnet’)
tf.app.flags.DEFINE_string(‘pre_model’,
”,#’./inception_v3.ckpt’,
‘checkpoint file’)
FLAGS = tf.app.flags.FLAGS
# Every 5k steps cut learning rate in half
def exponential_staircase_decay(at_step=10000, decay_rate=0.1):
print(‘decay [%f] every [%d] steps’ % (decay_rate, at_step))
def _decay(lr, global_step):
return tf.train.exponential_decay(lr, global_step,
at_step, decay_rate, staircase=True)
return _decay
def optimizer(optim, eta, loss_fn, at_step, decay_rate):
global_step = tf.Variable(0, trainable=False)
optz = optim
if optim == ‘Adadelta’:
optz = lambda lr: tf.train.AdadeltaOptimizer(lr, 0.95, 1e-6)
lr_decay_fn = None
elif optim == ‘Momentum’:
optz = lambda lr: tf.train.MomentumOptimizer(lr, MOM)
lr_decay_fn = exponential_staircase_decay(at_step, decay_rate)
return tf.contrib.layers.optimize_loss(loss_fn, global_step, eta,
optz, clip_gradients=4., learning_rate_decay_fn=lr_decay_fn)
def loss(logits, labels):
labels = tf.cast(labels, tf.int32)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=logits, labels=labels, name=’cross_entropy_per_example’)
cross_entropy_mean = tf.reduce_mean(cross_entropy,
name=’cross_entropy’)
tf.add_to_collection(‘losses’, cross_entropy_mean)
losses = tf.get_collection(‘losses’)
regularization_losses =
tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = cross_entropy_mean + LAMBDA *
sum(regularization_losses)
tf.summary.scalar(‘tl (raw)’, total_loss)
#total_loss = tf.add_n(losses + regularization_losses,
name=’total_loss’)
loss_averages = tf.train.ExponentialMovingAverage(0.9, name=’avg’)
loss_averages_op = loss_averages.apply(losses + [total_loss])
for l in losses + [total_loss]:
tf.summary.scalar(l.op.name + ‘ (raw)’, l)
tf.summary.scalar(l.op.name, loss_averages.average(l))
with tf.control_dependencies([loss_averages_op]):
total_loss = tf.identity(total_loss)
return total_loss
def main(argv=None):
with tf.Graph().as_default():
model_fn = select_model(FLAGS.model_type)
# Open the metadata file and figure out nlabels, and size of epoch
#
打开元数据文件md.json,这个文件是于预先处理数据经常变。找有nlabels、epoch大小
input_file = os.path.join(FLAGS.train_dir, ‘md.json’)
print(input_file)
with open(input_file, ‘r’) as f:
md = json.load(f)
images, labels, _ = distorted_inputs(FLAGS.train_dir,
FLAGS.batch_size, FLAGS.image_size, FLAGS.num_preprocess_threads)
logits = model_fn(md[‘nlabels’], images, 1-FLAGS.pdrop, True)
total_loss = loss(logits, labels)
train_op = optimizer(FLAGS.optim, FLAGS.eta, total_loss,
FLAGS.steps_per_decay, FLAGS.eta_decay_rate)
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
sess = tf.Session(config=tf.ConfigProto(
log_device_placement=FLAGS.log_device_placement))
tf.global_variables_initializer().run(session=sess)
# This is total hackland, it only works to fine-tune iv3
# 本例可以输入预训练模型Inception V3,可用来微调 Inception V3
if FLAGS.pre_model:
inception_variables = tf.get_collection(
tf.GraphKeys.VARIABLES, scope=”InceptionV3″)
restorer = tf.train.Saver(inception_variables)
restorer.restore(sess, FLAGS.pre_model)
if FLAGS.pre_checkpoint_path:
if tf.gfile.Exists(FLAGS.pre_checkpoint_path) is True:
print(‘Trying to restore checkpoint from %s’ %
FLAGS.pre_checkpoint_path)
restorer = tf.train.Saver()
tf.train.latest_checkpoint(FLAGS.pre_checkpoint_path)
print(‘%s: Pre-trained model restored from %s’ %
(datetime.now(), FLAGS.pre_checkpoint_path))
# 将ckpt文件存储于run-(pid)目录
run_dir = ‘%s/run-%d’ % (FLAGS.train_dir, os.getpid())
checkpoint_path = ‘%s/%s’ % (run_dir, FLAGS.checkpoint)
if tf.gfile.Exists(run_dir) is False:
print(‘Creating %s’ % run_dir)
tf.gfile.MakeDirs(run_dir)
tf.train.write_graph(sess.graph_def, run_dir, ‘model.pb’,
as_text=True)
tf.train.start_queue_runners(sess=sess)
summary_writer = tf.summary.FileWriter(run_dir, sess.graph)
steps_per_train_epoch = int(md[‘train_counts’] /
FLAGS.batch_size)
num_steps = FLAGS.max_steps if FLAGS.epochs < 1 else FLAGS.epochs
* steps_per_train_epoch
print(‘Requested number of steps [%d]’ % num_steps)

训练模型。https://github.com/dpressel/rude-carnie/blob/master/train.py

def parse_arguments(argv):
parser = argparse.ArgumentParser()

for i in range(1, batch_sz):
output = output + batch_results[i]

if step % 1000 == 0 or (step + 1) == num_steps:
saver.save(sess, checkpoint_path, global_step=step)
if __name__ == ‘__main__’:
tf.app.run()

# Run forward pass to calculate embeddings
# 3. 使用前于传播验证
print(‘Runnning forward pass on LFW images’)
batch_size = args.lfw_batch_size
nrof_images = len(paths)
nrof_batches = int(math.ceil(1.0*nrof_images / batch_size)) #
总共批次数
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches):
start_index = i*batch_size
end_index = min((i+1)*batch_size, nrof_images)
paths_batch = paths[start_index:end_index]
images = facenet.load_data(paths_batch, False, False, image_size)
feed_dict = { images_placeholder:images,
phase_train_placeholder:False }
emb_array[start_index:end_index,:] = sess.run(embeddings,
feed_dict=feed_dict)

LFW(Labeled Faces in the Wild
Home)数据集。http://vis-www.cs.umass.edu/lfw/
。美国马萨诸塞大学阿姆斯特分校计算机视觉实验室整理。13233摆放图片,5749人。4096人止生相同摆设图,1680丁大半给一致张。每张图片尺寸250×250。人脸图片在每个人物名文件夹下。

if __name__ == ‘__main__’:
tf.app.run()

参考资料:
《TensorFlow技术解析及实战》

Adience
数据集。http://www.openu.ac.il/home/hassner/Adience/data.html\#agegender
。26580张图纸,2284近乎,年龄限制8独区段(0~2、4~6、8~13、15~20、25~32、38~43、48~53、60~),含有噪声、姿势、光照变化。aligned
# 经过剪裁对伙同多少,faces #
原始数据。fold_0_data.txt至fold_4_data.txt
全部数目符号。fold_frontal_0_data.txt至fold_frontal_4_data.txt
仅用接近正面态度面部标记。数据结构 user_id
用户Flickr帐户ID、original_image 图片文件称、face_id
人标识符、age、gender、x、y、dx、dy 人脸边框、tilt_ang
切斜角度、fiducial_yaw_angle 基准偏移角度、fiducial_score
基准分数。https://www.flickr.com/