機器學習開發者應該收藏的 DIY 計算機視覺和深度學習項目

本文為雷鋒字幕組編譯的技術博客，原標題 DIY Deep Learning Projects，作者為Favio Vázquez。

翻譯 | 趙朋飛、林驍 整理 | 孔令雙

受到 Akshay Bahadur 所做偉大工作的鼓舞，在這篇文章中你將看到一些應用計算機視覺和深度學習的項目，包括具體實現和細節，你可以在自己的電腦上復現這些項目。

LinkedIn 數據科學社區

Akshay Bahadur 是 LinkedIn 數據科學社區給出的最好的榜樣。在其他諸如 Quora、StackOverflow、Youtube 等平台，有很多優秀的人，以及很多論壇和平台在科學、哲學、數學、語言學，以及數據科學等領域互相幫助。

Akshay Bahadur.

但我認為在過去的 ~3 年間，LinkedIn 社區在共享數據科學內容方面做的非常優秀，從分享經驗，到關於如何在現實世界進行機器學習的文章。我經常建議想從事這一領域的人加入這個社區，而且 LinkedIn 是最好的，你可以在那裡隨時找到我 :)。

從深度學習和計算機視覺開始

https://github.com/facebookresearch/Detectron

在這十年里，在深度學習領域中對圖像進行分類、檢測和執行相應動作的研究是非常重要的，其結果令人驚訝，有些問題的解決在性能已經超越了人類水平。

在這篇文章中，我將展示 Akshay Bahadur在計算機視覺和深度學習領域所做的工作。如果你對這些概念還不熟悉，可以通過閱讀下面這些內容學到更多：

對深度學習的「怪異」介紹

這裡有關於深度學習的精彩介紹、課程以及博客文章。但這是一種很獨特的介紹。

https://towardsdatascience.com/a-weird-introduction-to-deep-learning-7828803693b0

兩個月探索深度學習和計算機視覺

我決定深入了解計算機視覺和機器學習。作為一個網頁開發者，我發現了這個。

https://towardsdatascience.com/two-months-exploring-deep-learning-and-computer-vision-3dcc84b2457f

從神經科學到計算機視覺

人類和計算機視覺的50年。

https://towardsdatascience.com/from-neuroscience-to-computer-vision-e86a4dea3574

吳恩達計算機視覺 —— 11 個經驗教訓

我最近剛完成吳恩達在 Coursera 上的計算機視覺課程。吳恩達在解釋這些問題方面做了傑出的工作。

https://towardsdatascience.com/computer-vision-by-andrew-ng-11-lessons-learned-7d05c18a6999

1. 使用 OpenCV 手動執行

akshaybahadur21/HandMovementTracking

https://github.com/akshaybahadur21/HandMovementTracking

Akshay:

為了執行視頻追蹤，演算法需要分析視頻幀序列並輸出每幀之間的目標位移。有很多種演算法，每種各有強項和弱點。選擇使用哪種演算法，重要的是要考慮應用目的。視頻追蹤系統有兩個主要的組成部分：目標表示和定位，以及濾波和數據關聯。

視頻追蹤是通過攝像頭定位一個（或多個）移動目標的過程。擁有多種用途，比如，人機交互、安全監視、視頻通訊與壓縮、增強現實、交通控制、醫學影像，以及視頻編輯等。

下面是你在復現它時需要用到的代碼：

import numpyasnp

import cv2

import argparse

from collections import deque

cap=cv2.VideoCapture()

pts= deque(maxlen=64)

Lower_green = np.array([110,50,50])

Upper_green = np.array([130,255,255])

whileTrue:

ret, img=cap.read()

hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)

kernel=np.ones((5,5),np.uint8)

mask=cv2.inRange(hsv,Lower_green,Upper_green)

mask = cv2.erode(mask, kernel, iterations=2)

mask=cv2.morphologyEx(mask,cv2.MORPH_OPEN,kernel)

#mask=cv2.morphologyEx(mask,cv2.MORPH_CLOSE,kernel)

mask = cv2.dilate(mask, kernel, iterations=1)

res=cv2.bitwise_and(img,img,mask=mask)

cnts,heir=cv2.findContours(mask.copy(),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)[-2:]

center= None

iflen(cnts) >:

c=max(cnts, key=cv2.contourArea)

((x,y), radius) = cv2.minEnclosingCircle(c)

M = cv2.moments(c)

center= (int(M["m10"] / M["m00"]),int(M["m01"] / M["m00"]))

ifradius >5:

cv2.circle(img, (int(x),int(y)),int(radius),(,255,255),2)

cv2.circle(img,center,5, (,,255), -1)

pts.appendleft(center)

fori in xrange (1,len(pts)):

ifpts[i-1]isNoneorpts[i]isNone:

continue

thick =int(np.sqrt(len(pts) / float(i +1)) *2.5)

cv2.line(img,pts[i-1],pts[i],(,,225),thick)

cv2.imshow("Frame", img)

cv2.imshow("mask",mask)

cv2.imshow("res",res)

k=cv2.waitKey(30) &xFF

ifk==32:

break

# cleanup the cameraandcloseanyopenwindows

cap.release()

cv2.destroyAllWindows()

是的，54 行代碼，相當簡單？如果你的電腦檢查結果如下面所示的話，你需要先安裝 OpenCV：

在 MacOS 上安裝 OpenCV

這篇文章中，我么將逐步介紹在 MacOS 和 OSX 上安裝 OpenCV 3.3.0 (C++ and Python)。

https://www.learnopencv.com/install-opencv3-on-macos/

如果你使用 Ubuntu：

OpenCV：在 Ubuntu 上安裝 OpenCV-Python

有了所有必須的依賴項，讓我們安裝 OpenCV。需要使用 CMake 配置安裝選項項

https://docs.opencv.org/3.4.1/d2/de6/tutorial_py_setup_in_ubuntu.html

如果使用 Windows:

Windows 安裝 OpenCV-Python- OpenCV 3.0.0-dev documentation

在這篇教程中我們將學習在 Windows 系統中如何設置O penCV-Python。下面的步驟在 Windows 7-64 中測試通過

https://docs.opencv.org/3.0-beta/doc/py_tutorials/py_setup/py_setup_in_windows/py_setup_in_windows.html

2.基於 OpenCV 的疲勞檢測

akshaybahadur21/Drowsiness_Detection

https://github.com/akshaybahadur21/Drowsiness_Detection

駕駛員長時間駕駛有可能會導致事故發生。這段代碼檢測你的眼睛，瞌睡時會發出告警。

依賴項：

cv2

immutils

dlib

scipy

演算法

每個眼睛使用 6個 (x, y)坐標表示，從眼睛的左角開始（正如你看見人時一樣）, 然後沿著眼睛周圍順時針計算。

條件

檢查連續 20 幀圖像，如果眼睛長寬比小於 0.25，就發出告警。

關係

3. 使用 SoftMax 回歸進行數字識別

akshaybahadur21/Digit-Recognizer

在 Github.com 上的機器學習分類器－數字識別

https://github.com/akshaybahadur21/Digit-Recognizer

在程序中利用 SoftMax 回歸代碼能夠幫助你區分不同的數字。你可以為 Python 安裝 Conda，它可以為你提供所有與 Python 有關相關庫的編譯環境。

描述

Softmax 回歸是邏輯回歸的推廣，我們可以用它來解決多分類問題，假設這些分類是互斥的（同義詞：多項邏輯推理，最大熵分類器，或多類邏輯回歸）。相反，我們在二分類問題中通常使用邏輯回歸模型。

Python 實現

數據集使用 MNIST 數據集，同時圖像大小為 28*28，利用邏輯回歸、淺層神經網路和深層神經網路的方法將 0—9 進行分類。

三個模型當中最好的部分之一是使用 Numpy 函數庫，包括優化，前向傳播和後向傳播。

邏輯回歸：

importnumpyasnp

importmatplotlib.pyplotasplt

defsoftmax(z):

z -= np.max(z)

sm = (np.exp(z).T / np.sum(np.exp(z), axis=1))

returnsm

definitialize(dim1, dim2):

"""

:param dim: size of vector w initilazied with zeros

:return:

"""

w = np.zeros(shape=(dim1, dim2))

b = np.zeros(shape=(10,1))

returnw, b

defpropagate(w, b, X, Y):

"""

:param w: weights for w

:param b: bias

:param X: size of data(no of features, no of examples)

:param Y: true label

:return:

"""

m = X.shape[1]# getting no of rows

# Forward Prop

A = softmax((np.dot(w.T, X) + b).T)

cost = (-1/ m) * np.sum(Y * np.log(A))

# backwar prop

dw = (1/ m) * np.dot(X, (A - Y).T)

db = (1/ m) * np.sum(A - Y)

cost = np.squeeze(cost)

grads = {"dw": dw,

"db": db}

returngrads, cost

defoptimize(w, b, X, Y, num_iters, alpha, print_cost=False):

"""

:param w: weights for w

:param b: bias

:param X: size of data(no of features, no of examples)

:param Y: true label

:param num_iters: number of iterations for gradient

:param alpha:

:return:

"""

costs = []

foriinrange(num_iters):

grads, cost = propagate(w, b, X, Y)

dw = grads["dw"]

db = grads["db"]

w = w - alpha * dw

b = b - alpha * db

# Record the costs

ifi %50==:

costs.append(cost)

# Print the cost every 100 training examples

ifprint_costandi %50==:

print("Cost after iteration %i: %f"% (i, cost))

params = {"w": w,

"b": b}

grads = {"dw": dw,

"db": db}

returnparams, grads, costs

defpredict(w, b, X):

"""

:param w:

:param b:

:param X:

:return:

"""

# m = X.shape[1]

# y_pred = np.zeros(shape=(1, m))

# w = w.reshape(X.shape[0], 1)

y_pred = np.argmax(softmax((np.dot(w.T, X) + b).T), axis=)

returny_pred

defmodel(X_train, Y_train, Y,X_test,Y_test, num_iters, alpha, print_cost):

"""

:param X_train:

:param Y_train:

:param X_test:

:param Y_test:

:param num_iterations:

:param learning_rate:

:param print_cost:

:return:

"""

w, b = initialize(X_train.shape[], Y_train.shape[])

parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iters, alpha, print_cost)

w = parameters["w"]

b = parameters["b"]

y_prediction_train = predict(w, b, X_train)

y_prediction_test = predict(w, b, X_test)

print("Train accuracy: {} %", sum(y_prediction_train == Y) / (float(len(Y))) *100)

print("Test accuracy: {} %", sum(y_prediction_test == Y_test) / (float(len(Y_test))) *100)

d = {"costs": costs,

"Y_prediction_test": y_prediction_test,

"Y_prediction_train": y_prediction_train,

"w": w,

"b": b,

"learning_rate": alpha,

"num_iterations": num_iters}

# Plot learning curve (with costs)

#costs = np.squeeze(d["costs"])

#plt.plot(costs)

#plt.ylabel("cost")

#plt.xlabel("iterations (per hundreds)")

#plt.title("Learning rate =" + str(d["learning_rate"]))

#plt.plot()

#plt.show()

#plt.close()

#pri(X_test.T, y_prediction_test)

returnd

defpri(X_test, y_prediction_test):

example = X_test[2, :]

print("Prediction for the example is ", y_prediction_test[2])

plt.imshow(np.reshape(example, [28,28]))

plt.plot()

plt.show()

淺層神經網路

importnumpyasnp

importmatplotlib.pyplotasplt

defsoftmax(z):

z -= np.max(z)

sm = (np.exp(z).T / np.sum(np.exp(z),axis=1))

returnsm

deflayers(X, Y):

"""

:param X:

:param Y:

:return:

"""

n_x = X.shape[]

n_y = Y.shape[]

returnn_x, n_y

definitialize_nn(n_x, n_h, n_y):

"""

:param n_x:

:param n_h:

:param n_y:

:return:

"""

np.random.seed(2)

W1 = np.random.randn(n_h, n_x) *0.01

b1 = np.random.rand(n_h,1)

W2 = np.random.rand(n_y, n_h)

b2 = np.random.rand(n_y,1)

parameters = {"W1": W1,

"b1": b1,

"W2": W2,

"b2": b2}

returnparameters

defforward_prop(X, parameters):

W1 = parameters["W1"]

b1 = parameters["b1"]

W2 = parameters["W2"]

b2 = parameters["b2"]

Z1 = np.dot(W1, X) + b1

A1 = np.tanh(Z1)

Z2 = np.dot(W2, A1) + b2

A2 = softmax(Z2.T)

cache = {"Z1": Z1,

"A1": A1,

"Z2": Z2,

"A2": A2}

returnA2, cache

defcompute_cost(A2, Y, parameters):

m = Y.shape[1]

W1 = parameters["W1"]

W2 = parameters["W2"]

logprobs = np.multiply(np.log(A2), Y)

cost = - np.sum(logprobs) / m

cost = np.squeeze(cost)

returncost

defback_prop(parameters, cache, X, Y):

m = Y.shape[1]

W1 = parameters["W1"]

W2 = parameters["W2"]

A1 = cache["A1"]

A2 = cache["A2"]

dZ2 = A2 - Y

dW2 = (1/ m) * np.dot(dZ2, A1.T)

db2 = (1/ m) * np.sum(dZ2, axis=1, keepdims=True)

dZ1 = np.multiply(np.dot(W2.T, dZ2),1- np.square(A1))

dW1 = (1/ m) * np.dot(dZ1, X.T)

db1 = (1/ m) * np.sum(dZ1, axis=1, keepdims=True)

grads = {"dW1": dW1,

"db1": db1,

"dW2": dW2,

"db2": db2}

returngrads

defupdate_params(parameters, grads, alpha):

W1 = parameters["W1"]

b1 = parameters["b1"]

W2 = parameters["W2"]

b2 = parameters["b2"]

dW1 = grads["dW1"]

db1 = grads["db1"]

dW2 = grads["dW2"]

db2 = grads["db2"]

W1 = W1 - alpha * dW1

b1 = b1 - alpha * db1

W2 = W2 - alpha * dW2

b2 = b2 - alpha * db2

parameters = {"W1": W1,

"b1": b1,

"W2": W2,

"b2": b2}

returnparameters

defmodel_nn(X, Y,Y_real,test_x,test_y, n_h, num_iters, alpha, print_cost):

np.random.seed(3)

n_x,n_y = layers(X, Y)

parameters = initialize_nn(n_x, n_h, n_y)

W1 = parameters["W1"]

b1 = parameters["b1"]

W2 = parameters["W2"]

b2 = parameters["b2"]

costs = []

foriinrange(, num_iters):

A2, cache = forward_prop(X, parameters)

cost = compute_cost(A2, Y, parameters)

grads = back_prop(parameters, cache, X, Y)

if(i >1500):

alpha1 =0.95*alpha

parameters = update_params(parameters, grads, alpha1)

else:

parameters = update_params(parameters, grads, alpha)

ifi %100==:

costs.append(cost)

ifprint_costandi %100==:

print("Cost after iteration for %i: %f"% (i, cost))

predictions = predict_nn(parameters, X)

print("Train accuracy: {} %", sum(predictions == Y_real) / (float(len(Y_real))) *100)

predictions=predict_nn(parameters,test_x)

print("Train accuracy: {} %", sum(predictions == test_y) / (float(len(test_y))) *100)

#plt.plot(costs)

#plt.ylabel("cost")

#plt.xlabel("iterations (per hundreds)")

#plt.title("Learning rate =" + str(alpha))

#plt.show()

returnparameters

defpredict_nn(parameters, X):

A2, cache = forward_prop(X, parameters)

predictions = np.argmax(A2, axis=)

returnpredictions

以及最後的深層神經網路：

importnumpyasnp

importmatplotlib.pyplotasplt

defsoftmax(z):

cache = z

z -= np.max(z)

sm = (np.exp(z).T / np.sum(np.exp(z), axis=1))

returnsm, cache

defrelu(z):

"""

:param z:

:return:

"""

s = np.maximum(, z)

cache = z

returns, cache

defsoftmax_backward(dA, cache):

"""

:param dA:

:param activation_cache:

:return:

"""

z = cache

z -= np.max(z)

s = (np.exp(z).T / np.sum(np.exp(z), axis=1))

dZ = dA * s * (1- s)

returndZ

defrelu_backward(dA, cache):

"""

:param dA:

:param activation_cache:

:return:

"""

Z = cache

dZ = np.array(dA, copy=True)# just converting dz to a correct object.

dZ[Z

returndZ

definitialize_parameters_deep(dims):

"""

:param dims:

:return:

"""

np.random.seed(3)

params = {}

L = len(dims)

forlinrange(1, L):

params["W"+ str(l)] = np.random.randn(dims[l], dims[l -1]) *0.01

params["b"+ str(l)] = np.zeros((dims[l],1))

returnparams

deflinear_forward(A, W, b):

"""

:param A:

:param W:

:param b:

:return:

"""

Z = np.dot(W, A) + b

cache = (A, W, b)

returnZ, cache

deflinear_activation_forward(A_prev, W, b, activation):

"""

:param A_prev:

:param W:

:param b:

:param activation:

:return:

"""

ifactivation =="softmax":

Z, linear_cache = linear_forward(A_prev, W, b)

A, activation_cache = softmax(Z.T)

elifactivation =="relu":

Z, linear_cache = linear_forward(A_prev, W, b)

A, activation_cache = relu(Z)

cache = (linear_cache, activation_cache)

returnA, cache

defL_model_forward(X, params):

"""

:param X:

:param params:

:return:

"""

caches = []

A = X

L = len(params) //2# number of layers in the neural network

# Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list.

forlinrange(1, L):

A_prev = A

A, cache = linear_activation_forward(A_prev,

params["W"+ str(l)],

params["b"+ str(l)],

activation="relu")

caches.append(cache)

A_last, cache = linear_activation_forward(A,

params["W"+ str(L)],

params["b"+ str(L)],

activation="softmax")

caches.append(cache)

returnA_last, caches

defcompute_cost(A_last, Y):

"""

:param A_last:

:param Y:

:return:

"""

m = Y.shape[1]

cost = (-1/ m) * np.sum(Y * np.log(A_last))

cost = np.squeeze(cost)# To make sure your cost"s shape is what we expect (e.g. this turns [[17]] into 17).

returncost

deflinear_backward(dZ, cache):

"""

:param dZ:

:param cache:

:return:

"""

A_prev, W, b = cache

m = A_prev.shape[1]

dW = (1./ m) * np.dot(dZ, cache[].T)

db = (1./ m) * np.sum(dZ, axis=1, keepdims=True)

dA_prev = np.dot(cache[1].T, dZ)

returndA_prev, dW, db

deflinear_activation_backward(dA, cache, activation):

"""

:param dA:

:param cache:

:param activation:

:return:

"""

linear_cache, activation_cache = cache

ifactivation =="relu":

dZ = relu_backward(dA, activation_cache)

dA_prev, dW, db = linear_backward(dZ, linear_cache)

elifactivation =="softmax":

dZ = softmax_backward(dA, activation_cache)

dA_prev, dW, db = linear_backward(dZ, linear_cache)

returndA_prev, dW, db

defL_model_backward(A_last, Y, caches):

"""

:param A_last:

:param Y:

:param caches:

:return:

"""

grads = {}

L = len(caches)# the number of layers

m = A_last.shape[1]

Y = Y.reshape(A_last.shape)# after this line, Y is the same shape as A_last

dA_last = - (np.divide(Y, A_last) - np.divide(1- Y,1- A_last))

current_cache = caches[-1]

grads["dA"+ str(L)], grads["dW"+ str(L)], grads["db"+ str(L)] = linear_activation_backward(dA_last,

current_cache,

activation="softmax")

forlinreversed(range(L -1)):

current_cache = caches[l]

dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA"+ str(l +2)], current_cache,

activation="relu")

grads["dA"+ str(l +1)] = dA_prev_temp

grads["dW"+ str(l +1)] = dW_temp

grads["db"+ str(l +1)] = db_temp

returngrads

defupdate_params(params, grads, alpha):

"""

:param params:

:param grads:

:param alpha:

:return:

"""

L = len(params) //2# number of layers in the neural network

forlinrange(L):

params["W"+ str(l +1)] = params["W"+ str(l +1)] - alpha * grads["dW"+ str(l +1)]

params["b"+ str(l +1)] = params["b"+ str(l +1)] - alpha * grads["db"+ str(l +1)]

returnparams

defmodel_DL( X, Y, Y_real, test_x, test_y, layers_dims, alpha, num_iterations, print_cost):# lr was 0.009

"""

Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.

Arguments:

X -- data, numpy array of shape (number of examples, num_px * num_px * 3)

Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)

layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).

alpha -- learning rate of the gradient descent update rule

num_iterations -- number of iterations of the optimization loop

print_cost -- if True, it prints the cost every 100 steps

Returns:

params -- params learnt by the model. They can then be used to predict.

"""

np.random.seed(1)

costs = []# keep track of cost

params = initialize_parameters_deep(layers_dims)

foriinrange(, num_iterations):

A_last, caches = L_model_forward(X, params)

cost = compute_cost(A_last, Y)

grads = L_model_backward(A_last, Y, caches)

if(i >800andi

alpha1 =0.80* alpha

params = update_params(params, grads, alpha1)

elif(i>=1700):

alpha1 =0.50* alpha

params = update_params(params, grads, alpha1)

else:

params = update_params(params, grads, alpha)

ifprint_costandi %100==:

print("Cost after iteration %i: %f"% (i, cost))

ifprint_costandi %100==:

costs.append(cost)

predictions = predict(params, X)

print("Train accuracy: {} %", sum(predictions == Y_real) / (float(len(Y_real))) *100)

predictions = predict(params, test_x)

print("Test accuracy: {} %", sum(predictions == test_y) / (float(len(test_y))) *100)

#plt.plot(np.squeeze(costs))

#plt.ylabel("cost")

#plt.xlabel("iterations (per tens)")

#plt.title("Learning rate =" + str(alpha))

#plt.show()

returnparams

defpredict(parameters, X):

A_last, cache = L_model_forward(X, parameters)

predictions = np.argmax(A_last, axis=)

returnpredictions

通過攝像頭寫入

運行程序 python Dig-Rec.py

pythonDig-Rec.py

通過攝像頭展現傳入的代碼

運行程序 python Digit-Recognizer.py

pythonDigit-Recognizer.py

Devanagiri Recognizer

akshaybahadur21/Devanagiri-Recognizer

Devanagiri-Recognizer - 使用 convnetgithub.com 的印地語字母表分類器

這段代碼可以幫助你使用 Convnets 來分類不同的印地文字母（Devanagiri）。

https://github.com/akshaybahadur21/Devanagiri-Recognizer

你可以為 Python 安裝 Conda，它可以為你提供所有與 Python 有關相關庫的編譯環境。

使用的技術

我使用了卷積神經網路，Tensorflow 框架以及 Keras API 來提供高級的抽象。

結構

卷積層 池化層 卷積層 池化層 全連接層 Softmax 回歸層 分類

其他需要注意的事項

你還可以增加卷積層。

增加正則化防止過擬合。

增加圖片的數量來提高準確率。

Python 實現

DHCD （Devnagari Character Dataset）數據集的所有圖片尺寸都是 32 * 32 並且都用於卷積神經網路。

運行程序 python Dev-Rec.py

pythonDev-Rec.py

4. 使用 FaceNet 做面部識別

akshaybahadur21/ Facial-Recognition-using-FaceNet

https://github.com/akshaybahadur21/Facial-Recognition-using-Facenet

這段程序利用 facenet 網路幫助你做面部識別(https://arxiv.org/pdf/1503.03832.pdf). Facenets 的概念最初是在一篇研究論文中提出的。主要概念討論了三重損失函數來比較不同人的圖像。這個概念使用的是 Inception 網路，來自於 DeepingLearning.ai社區的 frutils.py 文件。在我的網路當中我增加了一些函數來提高穩定性和更好的檢測。

必備的代碼庫

你可以為 Python 安裝 Conda，它可以為你提供所有與 Python 有關相關庫的編譯環境，以下是你可能需要的庫：

numpy

matplotlib

cv2

keras

dlib

h5py

scipy

描述

面部識別系統是能夠從數字圖像或者視頻中識別或驗證人面部的技術。構建面部識別系統這裡有很多種方法，但是通常，他們是通過比較圖片中選擇的面部特徵和數據集中的特徵來進行判斷。

添加的功能

只有當你的眼睛睜開是才能偵測到面部。

使用 dlib 庫的面部對齊功能在實時流媒體上進行有效的預測。

Python 實現

使用 Inception Network 來搭建網路

源論文來自於Google－Facenet

程序

如果你想訓練網路，請運行 Train-inception.py, 若你不想訓練網路，因為我早已經訓練好了一個網路，那麼你可以下載該文件到本地運行 face-rec_Google.h5 。

現在你已經有了一個數據集，裡面包含了很多圖片。 點擊文件 /images來摺疊這些照片。您可以將圖片粘貼到此處，也可以使用網路攝像頭進行點擊。你可以運行該文件 create-face.py 來做到這一點，圖片都存儲在文件夾 /incept 中。你必須手動粘貼到文件夾中 /images folder。

運行程序 rec-feat.py 來實現所有的功能。

5. Emojinator

akshaybahadur21/ Emojinator

Emojinator - Github 上一個簡單的表情分類器。

https://github.com/akshaybahadur21/Emojinator

這些代碼能夠幫助你區分不同的表情。到目前為止，我們只支持手的表情。

必備的代碼庫

你可以為 Python 安裝 Conda，它可以為你提供所有與 Python 有關相關庫的編譯環境，以下是你可能需要的庫：

numpy

matplotlib

cv2

keras

dlib

h5py

scipy

描述

表情符號是電子信息和網頁中使用的表意符號和微笑符號。表情符號存在於不同的類型中，包括面部表情、常見物體、地點和天氣類型以及動物。它們很像表情符號，但表情符號是真實的圖片，而不是印刷圖。

功能

利用過濾器來檢測手。

利用 CNN 來訓練模型。

Python 實現

使用卷積神經網路

過程

首先，你需要一個手勢圖片的資料庫，你可以運行該文件來獲得 CreateGest.py。輸入手勢名稱，你可以看到兩個框架。按「C」進行拍攝。看看輪廓框架並調整你的手，以確保你捕捉到你的手的特徵。一個手勢可以拍 1200 張照片。試著在框架內移動你的手，以確保你的模型在訓練過程當中不會過擬合。

重複以上操作，保證你可以獲得所有你想要的特徵。

運行程序 CreateCSV.py 來將圖片轉換成 CSV 文件。

如果你想訓練模型，則運行程序 『TrainEmojinator.py』

最後，運行程序 Emojinator.py ，通過攝像頭來測試你的模型

作者

Akshay Bahadur 和 Raghav Patnecha.

結語

我只能說我對這些項目感到難以置信，所有人都可以在計算機上運行它們，或者在 Deep Cognition 的平台上運行它們，如果你不想安裝任何東西，它可以在線運行。

我想感謝 Akshay 和他的朋友們為開放源代碼貢獻力量以及所有其他將來的貢獻。嘗試一下，運行它們，並獲得靈感。這只是 DL 和 CV 可以做的令人驚嘆的事情的一個小例子，取決於你如何將它變成可以幫助世界變得更好的地方。

永不放棄，我們需要每個人都對許多不同的事情感興趣。我認為我們可以改善世界，改善我們的生活，我們的工作方式，思考和解決問題，如果我們引導現在的所有資源，使這些知識領域共同努力，實現更大的利益，我們可以在世界和我們的生活中產生巨大的積極影響。

我們需要更多的人感興趣，更多課程，更專業化，更熱情。我們需要你：）

感謝您閱讀到這，希望您可以在這裡發現更多有意思的是：）

如果你有任何問題，請在 Twitter 和 LinkedIn 上聯繫我：

Favio Vázquez (@FavioVaz) | Twitter

LinkedIn：

Favio Vázquez?—?Principal Data Scientist?—?OXXO | LinkedIn

2018 最新機器學習 API 推薦清單，快給 APP 加點智能

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！