Commit for merge

+import torch
+import numpy as np
+import time
+
+
+class Logger(object):
+
+    def __init__(self, mode, length, calculate_mean=False):
+        self.mode = mode
+        self.length = length
+        self.calculate_mean = calculate_mean
+        if self.calculate_mean:
+            self.fn = lambda x, i: x / (i + 1)
+        else:
+            self.fn = lambda x, i: x
+
+    def __call__(self, loss, metrics, i):
+        track_str = '\r{} | {:5d}/{:<5d}| '.format(self.mode, i + 1, self.length)
+        loss_str = 'loss: {:9.4f} | '.format(self.fn(loss, i))
+        metric_str = ' | '.join('{}: {:9.4f}'.format(k, self.fn(v, i)) for k, v in metrics.items())
+        print(track_str + loss_str + metric_str + '   ', end='')
+        if i + 1 == self.length:
+            print('')
+
+
+class BatchTimer(object):
+    """Batch timing class.
+    Use this class for tracking training and testing time/rate per batch or per sample.
+    
+    Keyword Arguments:
+        rate {bool} -- Whether to report a rate (batches or samples per second) or a time (seconds
+            per batch or sample). (default: {True})
+        per_sample {bool} -- Whether to report times or rates per sample or per batch.
+            (default: {True})
+    """
+
+    def __init__(self, rate=True, per_sample=True):
+        self.start = time.time()
+        self.end = None
+        self.rate = rate
+        self.per_sample = per_sample
+
+    def __call__(self, y_pred, y):
+        self.end = time.time()
+        elapsed = self.end - self.start
+        self.start = self.end
+        self.end = None
+
+        if self.per_sample:
+            elapsed /= len(y_pred)
+        if self.rate:
+            elapsed = 1 / elapsed
+
+        return torch.tensor(elapsed)
+
+
+def accuracy(logits, y):
+    _, preds = torch.max(logits, 1)
+    return (preds == y).float().mean()
+
+
+def pass_epoch(
+    model, loss_fn, loader, optimizer=None, scheduler=None,
+    batch_metrics={'time': BatchTimer()}, show_running=True,
+    device='cpu', writer=None
+):
+    """Train or evaluate over a data epoch.
+    
+    Arguments:
+        model {torch.nn.Module} -- Pytorch model.
+        loss_fn {callable} -- A function to compute (scalar) loss.
+        loader {torch.utils.data.DataLoader} -- A pytorch data loader.
+    
+    Keyword Arguments:
+        optimizer {torch.optim.Optimizer} -- A pytorch optimizer.
+        scheduler {torch.optim.lr_scheduler._LRScheduler} -- LR scheduler (default: {None})
+        batch_metrics {dict} -- Dictionary of metric functions to call on each batch. The default
+            is a simple timer. A progressive average of these metrics, along with the average
+            loss, is printed every batch. (default: {{'time': iter_timer()}})
+        show_running {bool} -- Whether or not to print losses and metrics for the current batch
+            or rolling averages. (default: {False})
+        device {str or torch.device} -- Device for pytorch to use. (default: {'cpu'})
+        writer {torch.utils.tensorboard.SummaryWriter} -- Tensorboard SummaryWriter. (default: {None})
+    
+    Returns:
+        tuple(torch.Tensor, dict) -- A tuple of the average loss and a dictionary of average
+            metric values across the epoch.
+    """
+    
+    mode = 'Train' if model.training else 'Valid'
+    logger = Logger(mode, length=len(loader), calculate_mean=show_running)
+    loss = 0
+    metrics = {}
+
+    for i_batch, (x, y) in enumerate(loader):
+        x = x.to(device)
+        y = y.to(device)
+        y_pred = model(x)
+        loss_batch = loss_fn(y_pred, y)
+
+        if model.training:
+            loss_batch.backward()
+            optimizer.step()
+            optimizer.zero_grad()
+
+        metrics_batch = {}
+        for metric_name, metric_fn in batch_metrics.items():
+            metrics_batch[metric_name] = metric_fn(y_pred, y).detach().cpu()
+            metrics[metric_name] = metrics.get(metric_name, 0) + metrics_batch[metric_name]
+            
+        if writer is not None and model.training:
+            if writer.iteration % writer.interval == 0:
+                writer.add_scalars('loss', {mode: loss_batch.detach().cpu()}, writer.iteration)
+                for metric_name, metric_batch in metrics_batch.items():
+                    writer.add_scalars(metric_name, {mode: metric_batch}, writer.iteration)
+            writer.iteration += 1
+        
+        loss_batch = loss_batch.detach().cpu()
+        loss += loss_batch
+        if show_running:
+            logger(loss, metrics, i_batch)
+        else:
+            logger(loss_batch, metrics_batch, i_batch)
+    
+    if model.training and scheduler is not None:
+        scheduler.step()
+
+    loss = loss / (i_batch + 1)
+    metrics = {k: v / (i_batch + 1) for k, v in metrics.items()}
+            
+    if writer is not None and not model.training:
+        writer.add_scalars('loss', {mode: loss.detach()}, writer.iteration)
+        for metric_name, metric in metrics.items():
+            writer.add_scalars(metric_name, {mode: metric})
+
+    return loss, metrics
+
+
+def collate_pil(x): 
+    out_x, out_y = [], [] 
+    for xx, yy in x: 
+        out_x.append(xx) 
+        out_y.append(yy) 
+    return out_x, out_y 

+##################################################
+#1. webcam에서 얼굴을 인식합니다
+#2. 인식한 얼굴을 등록합니다
+##################################################
+import torch
+import numpy as np
+import cv2
+import asyncio
+import websockets
+import json
+import os
+import timeit
+import base64
+
+from PIL import Image
+from io import BytesIO
+import requests
+
+from models.mtcnn import MTCNN
+
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+print('Running on device: {}'.format(device))
+
+mtcnn = MTCNN(keep_all=True, device=device)
+
+uri = 'ws://169.56.95.131:8765'
+
+async def send_face(face_list, image_list):
+    global uri
+    async with websockets.connect(uri) as websocket:
+        for face, image in zip(face_list, image_list):
+            #type: np.float32
+            send = json.dumps({'action': 'register', 'student_id':'2014104149', 'student_name':'정해갑', 'MTCNN': face.tolist()})
+            await websocket.send(send)
+            recv = await websocket.recv()
+            data = json.loads(recv)
+            if data['status'] == 'success':
+                # 성공
+                print(data['student_id'], 'is registered')
+
+def detect_face(frame):
+    # If required, create a face detection pipeline using MTCNN:
+    global mtcnn
+    results = mtcnn.detect(frame)
+    image_list = []
+    if results[1][0] == None:
+        return []
+    for box, prob in zip(results[0], results[1]):
+        if prob < 0.95:
+            continue
+        print('face detected. prob:', prob)
+        x1, y1, x2, y2 = box
+        image = frame[int(y1-10):int(y2+10), int(x1-10):int(x2+10)]
+        image_list.append(image)
+    return image_list
+
+def detect_face(frame):
+    results = mtcnn.detect(frame)
+    faces = mtcnn(frame, return_prob = False)
+    image_list = []
+    face_list = []
+    if results[1][0] == None:
+        return [], []
+    for box, face, prob in zip(results[0], faces, results[1]):
+        if prob < 0.97:
+            continue
+        print('face detected. prob:', prob)
+        x1, y1, x2, y2 = box
+        if (x2-x1) * (y2-y1) < 15000:
+            # 얼굴 해상도가 너무 낮으면 무시
+            continue
+        # 얼굴 주변 ±3 영역  저장
+        image = frame[int(y1-3):int(y2+3), int(x1-3):int(x2+3)]
+        image_list.append(image)
+        # MTCNN 데이터 저장
+        face_list.append(face.numpy())
+    return image_list, face_list
+
+cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+cap.set(3, 720)
+cap.set(4, 480)
+ret, frame = cap.read()
+frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+image_list, face_list = detect_face(frame)
+if face_list:
+    asyncio.get_event_loop().run_until_complete(send_face(face_list, image_list))
\ No newline at end of file