cv2.imshow ( "Frame", img)

cv2.imshow ( "masque", masque)

cv2.imshow ( "res", res)

k = cv2.waitKey (30) & 0xFF

si k == 32:

pause

# Nettoyage de l'appareil photo et fermez toutes les fenêtres ouvertes

cap.release

cv2.destroyAllWindows

Oui, 54 lignes de code, est assez simple? Si votre ordinateur pour vérifier les résultats présentés ci-dessous, vous devez installer OpenCV:

Installation OpenCV sur MacOS

Dans cet article, je vais marcher installé OpenCV 3.3.0 (C ++ et Python) sur MacOS et OSX.

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

Si vous utilisez Ubuntu:

OpenCV: Installation OpenCV-Python sur Ubuntu

Avec toutes les dépendances nécessaires, nous allons installer OpenCV. Vous devez utiliser CMake pour configurer les options d'installation des éléments

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

Si vous utilisez Windows:

Windows Installer OpenCV-Python- OpenCV documentation 3.0.0-dev

Dans ce tutoriel, nous allons apprendre comment configurer O penCV-Python sur les systèmes Windows. Les étapes suivantes dans Windows 7-64 testé par

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

2. La détection de la fatigue basée sur OpenCV

akshaybahadur21 / Drowsiness_Detection

GitHub.github.com Créer un compte contribue au développement du projet à la détection de la fatigue

https://github.com/akshaybahadur21/Drowsiness_Detection

La conduite de longue date du conducteur peut provoquer un accident. Ce code détecte vos yeux, émettra un avertissement lorsque endormi.

dépendance:

• CV2

• immutils

• Dlib

• scipy

algorithme

6 chaque oeil en utilisant (x, y) de coordonnées de représentation, (le même que quand on voit al.) A partir du coin gauche de l'oeil, puis l'oeil est calculée dans le sens horaire le long de la circonférence.

condition

Voir les images de trame en continu 20, si le rapport d'aspect est inférieur à 0,25 oeil, une alarme est émise.

rapports

3. régression SoftMax identification numérique

akshaybahadur21 / chiffre-Recognizer

Le classificateur d'apprentissage machine Github.com - identification numérique

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

SOFTMAX utiliser les codes de retour dans un programme qui peut vous aider à distinguer entre les différents numéros. Vous pouvez installer Conda comme Python, il peut fournir une compilation de toutes les bibliothèques Python environnement pertinents et connexes pour vous.

description

régression softmax est une généralisation de la régression logistique, nous pouvons l'utiliser pour résoudre le problème multi-classification, en supposant que ces catégories sont mutuellement exclusives (synonyme: un certain nombre de raisonnement logique, classificateur entropie maximale, ou classes de régression logistique). , Nous utilisons habituellement plutôt le modèle de régression logistique dans le second problèmes de classification.

la mise en uvre Python

Dataset MNIST ensemble de données, alors que la taille de l'image est de 28 * 28, en utilisant la régression logistique, les réseaux de neurones des couches superficielles et profondes du réseau de neurones à classer 0-9.

Une partie des trois meilleurs modèles sont utilisés bibliothèques qui NumPy, y compris l'optimisation, la propagation vers l'avant et la propagation de retour.

La régression logistique:

importer numpy comme np

matplotlib.pyplot importation comme plt

def softmax (z):

z - = np.max (z)

sm = (np.exp (z) .T / np.sum (np.exp (z), l'axe = 1))

retour sm

def initialize (dim1, dim2):

« » "

: Param dim: taille du vecteur w initilazied avec des zéros

: Retour:

« » "

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

b = (= np.zeros de forme (10, 1))

retourner w, b

def propager (w, b, X, Y):

« » "

: Param w: w poids pour

: Param b: polarisation

: X Param: taille des données (pas de caractéristiques, pas d'exemples)

: Y Param: véritable label

: Retour:

« » "

m = X.shape # obtenir pas de lignes

# Forward Prop

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

coût = (-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)

coût = np.squeeze (coût)

= {Grads "dw": dw,

"Db": db}

Grads retour, le coût

def optimize (w, b, X, Y, num_iters, alpha, print_cost = false):

« » "

: Param w: w poids pour

: Param b: polarisation

: X Param: taille des données (pas de caractéristiques, pas d'exemples)

: Y Param: véritable label

: Param num_iters: nombre d'itérations pour gradient

: Param alpha:

: Retour:

« » "

coûts =

for i in range (num_iters):

grades, coût = propagation (w, b, X, Y)

dw = Grads

db = Grads

w = w - alpha * dw

b = b - alpha * db

# Enregistrer les coûts

si i% 50 == 0:

costs.append (coût)

# Imprimer le coût 100 exemples de formation

si print_cost et i% 50 == 0:

print ( "Coût après itération% i:% f" % (i, coût))

params = { "w": w,

"B": b}

= {Grads "dw": dw,

"Db": db}

retour params, Grads, coûts

def prédire (w, b, X):

« » "

: Param w:

: B Param:

: X Param:

: Retour:

« » "

# M = X.shape

# Y_pred = np.zeros (forme = (1, m))

# W = w.reshape (X.shape , 1)

y_pred = np.argmax (softmax ((np.dot (w.T, X) + b) .T), l'axe = 0)

retour y_pred

modéliser def (X_train, Y_train, Y, X_test, Y_test, num_iters, alpha, print_cost):

« » "

: X_train Param:

: Y_train Param:

: X_test Param:

: Y_test Param:

: PARAM num_iterations:

: Learning_rate Param:

: Print_cost Param:

: Retour:

« » "

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

les paramètres, les grades, les coûts = Optimiser (w, b, X_train, Y_train, num_iters, alpha, print_cost)

w = paramètre

b = paramètres

y_prediction_train = prédire (w, b, X_train)

y_prediction_test = prédire (w, b, X_test)

print ( "précision de train: {}%", somme (y_prediction_train == Y) / (flotteur (len (Y))) * 100)

print ( "Test de précision: {}%", somme (y_prediction_test == Y_test) / (flotteur (len (Y_test))) * 100)

d = { "coûts": les coûts,

"Y_prediction_test": y_prediction_test,

"Y_prediction_train": y_prediction_train,

"W": w,

"B": b,

"Learning_rate": alpha,

"Num_iterations": num_iters}

# Courbe d'apprentissage de terrain (avec frais)

#costs = np.squeeze (d )

# Plt.plot (coûts)

# Plt.ylabel ( 'coût')

# Plt.xlabel ( 'itérations (par centaines)')

# Plt.title ( "taux d'apprentissage =" + str (d ))

# Plt.plot

# Plt.show

# Plt.close

#pri (X_test.T, y_prediction_test)

retour d

def pri (X_test, y_prediction_test):

exemple = X_test

print ( "Prévision pour l'exemple est", y_prediction_test )

plt.imshow (np.reshape (par exemple, ))

plt.plot

plt.show

Faible profondeur réseau de neurones

importer numpy comme np

matplotlib.pyplot importation comme plt

def softmax (z):

z - = np.max (z)

sm = (np.exp (z) .T / np.sum (np.exp (z), l'axe = 1))

retour sm

def couches (X, Y):

« » "

: X Param:

: Param Y:

: Retour:

« » "

n_x = X.shape

n_y = Y.shape

retour n_x, n_y

def initialize_nn (n_x, N_H, n_y):

« » "

: N_x Param:

: N_H Param:

: N_y Param:

: Retour:

« » "

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)

paramètres = { "W1": W1,

"B1": b1,

"W2": W2,

"B2": b2}

paramètres de retour

def forward_prop (X, paramètres):

W1 = paramètres

b1 = paramètres

W2 = paramètres

b2 = paramètres

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}

retour A2, cache

def compute_cost (A2, Y, paramètres):

m = Y.shape

W1 = paramètres

W2 = paramètres

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

coût = - (np.sum logprobs) / m

coût = np.squeeze (coût)

coût retour

def back_prop (paramètres, cache, X, Y):

m = Y.shape

W1 = paramètres

W2 = paramètres

A1 = cache

A2 = cache

DZ2 = A2 - Y

DW2 = (1 / m) * np.dot (DZ2, A1.T)

db2 = (1 / m) * np.sum (DZ2, axe = 1, keepdims = Vrai)

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, axe = 1, keepdims = Vrai)

= {Grads "DW1": DW1,

"Db1": DB1,

"DW2": DW2,

"Db2": db2}

Grads de retour

def update_params (paramètres, les grades alpha):

W1 = paramètres

b1 = paramètres

W2 = paramètres

b2 = paramètres

DW1 = Grads

DB1 = Grads

DW2 = Grads

db2 = Grads

W1 = W1 - alpha * DW1

b1 = b1 - alpha * db1

W2 = W2 - alpha * DW2

b2 = b2 - alpha * db2

paramètres = { "W1": W1,

"B1": b1,

"W2": W2,

"B2": b2}

paramètres de retour

def model_nn (X, Y, Y_real, test_x, test_y, N_H, num_iters, alpha, print_cost):

np.random.seed (3)

n_x, n_y = couches (X, Y)

paramètres = initialize_nn (n_x, N_H, n_y)

W1 = paramètres

b1 = paramètres

W2 = paramètres

b2 = paramètres

coûts =

pour i dans la plage (0, num_iters):

A2, cache = forward_prop (X, paramètres)

coût = compute_cost (A2, Y, paramètres)

grades = back_prop (paramètres, cache, X, Y)

si (i >  1500):

alpha1 = 0,95 * alpha

paramètres = update_params (paramètres, grades, alpha1)

autre:

paramètres = update_params (paramètres, grades, alpha)

si i == 0% 100:

costs.append (coût)

si print_cost et i == 0% 100:

print ( "Coût après itération pour% i:% f" % (i, coût))

prédictions = predict_nn (paramètres, X)

print ( "précision de train: {}%", somme (de prévisions Y_real) / (flotteur (len (Y_real))) * 100)

prédictions = predict_nn (paramètres, test_x)

print ( "précision de train: {}%", somme (la test_y de prédictions) / (flotteur (len (test_y))) * 100)

# Plt.plot (coûts)

# Plt.ylabel ( 'coût')

# Plt.xlabel ( 'itérations (par centaines)')

# Plt.title ( "taux d'apprentissage =" + str (alpha))

# Plt.show

paramètres de retour

def predict_nn (paramètres, X):

A2, cache = forward_prop (X, paramètres)

prédictions = np.argmax (A2, axe = 0)

prévisions de retour

Et, enfin, DNN:

importer numpy comme np

matplotlib.pyplot importation comme plt

def softmax (z):

cache = z

z - = np.max (z)

sm = (np.exp (z) .T / np.sum (np.exp (z), l'axe = 1))

retour sm, cache

def Relu (z):

« » "

: Param z:

: Retour:

« » "

s = np.maximum (0, z)

cache = z

retour, cache

def softmax_backward (dA, cache):

« » "

: DA Param:

: Activation_cache Param:

: Retour:

« » "

z = cache

z - = np.max (z)

s = (np.exp (z) .T / np.sum (np.exp (z), l'axe = 1))

dZ = dA * s * (1 - s)

retour dZ

def relu_backward (dA, cache):

« » "

: DA Param:

: Activation_cache Param:

: Retour:

« » "

Z = cache

dZ = np.array (dA, copie = true) # simplement convertir dz à un objet correct.

dZ en 17).

coût retour

def linear_backward (dZ, cache):

« » "

: DZ Param:

: Cache Param:

: Retour:

« » "

A_prev, W, b = cache

m = A_prev.shape

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

db = (1 / m) * np.sum (dZ, axe = 1, keepdims = Vrai)

dA_prev = np.dot (cache .T, dZ)

retour dA_prev, dW, db

def linear_activation_backward (dA, cache, activation):

« » "

: DA Param:

: Cache Param:

: Activation Param:

: Retour:

« » "

linear_cache, activation_cache = cache

si l'activation == "Relu":

dZ = relu_backward (dA, activation_cache)

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

Elif activation == "softmax":

dZ = softmax_backward (dA, activation_cache)

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

retour dA_prev, dW, db

def L_model_backward (A_last, Y, des caches):

« » "

: A_last Param:

: Param Y:

: Met en cache Param:

: Retour:

« » "

Grads = {}

L = len (caches) # le nombre de couches

m = A_last.shape

Y = Y.reshape (A_last.shape) # après cette ligne, Y est la même forme que A_last

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

current_cache = caches

Diplômées , grades , grades = linear_activation_backward (dA_last,

current_cache,

activation = "softmax")

L inversé en (plage (L - 1)):

current_cache = caches

dA_prev_temp, dW_temp, DB_Temp = linear_activation_backward (grades , current_cache,

activation = "relu")

grades = dA_prev_temp

grades = dW_temp

grades = DB_Temp

Grads de retour

def update_params (params, grades, alpha):

« » "

: Params Param:

: Param Grads:

: Param alpha:

: Retour:

« » "

L = len (params) // 2 # nombre de couches dans le réseau de neurones

L dans la gamme (L):

params = params - * alpha grades

params = params - * alpha grades

params de retour

def model_DL (X, Y, Y_real, test_x, test_y, layers_dims, alpha, num_iterations, print_cost): # lr était 0,009

« » "

Met en uvre un réseau neuronal L-couche: * (L-1) - > Linear > Sigmoïde.

arguments:

X - données, réseau numpy de forme (nombre d'exemples, num_px * num_px * 3)

Y - vrai vecteur "label" (contenant 0 si chat, si une non-cat), de forme (1, nombre d'exemples)

layers_dims - liste contenant la taille d'entrée, et chaque taille de la couche, de longueur (nombre de couches + 1).

taux d'apprentissage de la règle de mise à jour de descente de gradient - alpha

num_iterations - nombre d'itérations de la boucle d'optimisation

print_cost - si vrai, il imprime le coût 100 étapes

Retours:

params - params appris par le modèle Ils peuvent alors être utilisés pour prédire ..

« » "

np.random.seed (1)

coûts = # assurer le suivi des coûts

params = initialize_parameters_deep (layers_dims)

pour i dans la plage (0, num_iterations):

A_last, caches = L_model_forward (X, params)

coût = compute_cost (A_last, Y)

grades = L_model_backward (A_last, Y, caches)

si (i >  800 et i = alpha10,80 * alpha

params = update_params (params, grades, alpha1)

elif (i > = 1700):

alpha1 = 0,50 * alpha

params = update_params (params, grades, alpha1)

autre:

params = update_params (params, grades, alpha)

si print_cost et i == 0% 100:

print ( "Coût après itération% i:% f" % (i, coût))

si print_cost et i == 0% 100:

costs.append (coût)

prédictions = prédire (params, X)

print ( "précision de train: {}%", somme (de prévisions Y_real) / (flotteur (len (Y_real))) * 100)

prédictions = prédire (params, test_x)

print ( "Test de précision: {}%", somme (la test_y de prédictions) / (flotteur (len (test_y))) * 100)

# Plt.plot (np.squeeze (coûts))

# Plt.ylabel ( 'coût')

# Plt.xlabel ( 'itérations (par dizaines)')

# Plt.title ( "taux d'apprentissage =" + str (alpha))

# Plt.show

params de retour

def prédire (paramètres, X):

A_last, cache = L_model_forward (X, paramètres)

prédictions = np.argmax (A_last, axe = 0)

prévisions de retour

Rédigé par caméra

Exécutez le programme python Dig-Rec.py

python Dig-Rec.py

Pour afficher le code d'entrée via la caméra

Exécutez le programme python Digit-Recognizer.py

python Digit-Recognizer.py

Devanagiri Recognizer

akshaybahadur21 / Devanagiri-Recognizer

Devanagiri-Recognizer - utilisation convnetgithub.com classificateur alphabet hindi

Ce code peut vous aider à utiliser Convnets à classer les différents alphabet hindi (Devanagiri).

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

Vous pouvez installer Conda comme Python, il peut fournir une compilation de toutes les bibliothèques Python environnement pertinents et connexes pour vous.

Utilisation de la technologie

Je convolution réseau de neurones, tensorflow Keras cadre de l'API, ainsi que de fournir de haut niveau d'abstraction.

structure

couche de cellules de la couche de convolution convolutif couche de cellules de la couche couche entièrement connecté la couche de classification de régression Softmax

Autres points à noter:

la mise en uvre Python

Toutes les tailles d'image DHCD (Devnagari caractères du jeu de données) * ensemble de données 32 et 32 sont utilisés à la fois pour le réseau neuronal convolutif.

Exécutez le programme python Dev-Rec.py

python Dev-Rec.py

4. Utilisez une reconnaissance faciale FaceNet

akshaybahadur21 / reconnaissance faciale utilisant-FaceNet

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

Ce programme utilise le réseau facenet pour vous aider à faire la reconnaissance faciale (https://arxiv.org/pdf/1503.03832.pdf). Idée Facenets a été proposée dans le document de recherche. Les principaux concepts ont discuté d'une triple perte de fonction de comparer les différentes images de personnes. Ce concept est utilisé réseau de lancement, à partir du fichier frutils.py communautaire DeepingLearning.ai. Dans mon réseau que j'ai ajouté quelques fonctions pour améliorer la stabilité et une meilleure détection.

La bibliothèque de code nécessaire

Vous pouvez installer Python Conda, il peut fournir une compilation de toutes les bibliothèques Python environnement pertinents et connexes pour vous, vous pourriez avoir besoin les bibliothèques suivantes:

• numpy

• matplotlib

• CV2

• keras

• Dlib

• h5py

• scipy

description

système de reconnaissance faciale est en mesure d'identifier ou de vérifier le visage de la personne technique à partir d'une image numérique ou vidéo. La construction du système de reconnaissance faciale où il existe de nombreuses façons, mais en général, ils se caractérisent en comparant les données d'image du visage et l'ensemble des fonctions sélectionnées à déterminer.

Ajout d'une fonctionnalité

• Seulement lorsque vous ouvrez vos yeux est de détecter le visage.

• Bibliothèque en utilisant la fonction d'alignement de face Dlib efficace pour prédire en temps réel streaming media.

la mise en uvre Python

• Utilisation du réseau de lancement de la construction du réseau

• papier Source de Google-Facenet

programme

5. Emojinator

akshaybahadur21 / Emojinator

Emojinator - sur Github un classificateur d'expression simple.

https://github.com/akshaybahadur21/Emojinator

Ces codes peuvent vous aider à distinguer entre les différentes expressions. Jusqu'à présent, nous soutenons que l'expression de la main.

Les smileys sont des symboles idéogramme et souriant de l'information électronique et l'utilisation du Web. Émoticônes existent dans différents types, y compris les expressions du visage, des objets communs, les lieux et les types de conditions météorologiques et les animaux. Ils aiment émoticônes, mais émoticônes sont l'image réelle, plutôt que l'image d'impression.

fonction

la mise en uvre Python

L'utilisation d'un réseau de neurones convolution

processus

auteur

Akshay Bahadur et Raghav Patnecha.

épilogue

Je peux seulement dire que je me sens incroyable sur ces projets, tout le monde peut les exécuter sur un ordinateur, ou les exécuter sur la plate-forme profonde Cognition, si vous ne voulez pas installer quoi que ce soit, il peut être exécuté en ligne.

Je tiens à remercier Akshay et ses amis à contribuer à l'avenir, ainsi que toutes les autres contributions à l'open source. Essayez de les exécuter, et laissez-vous inspirer. Ceci est juste un petit exemple de DL et CV peut faire des choses étonnantes, selon la façon dont vous le transformer en un lieu qui peut aider le monde aille mieux.

Ne renoncez jamais, nous avons besoin de tout le monde intéressé à beaucoup de choses différentes. Je pense que nous pouvons améliorer le monde, améliorer notre vie, le travail de façon que nous, de penser et de résoudre des problèmes, si nous orientons toutes les ressources sont maintenant faire ces domaines de travail de connaissances pour obtenir des avantages plus importants, nous pouvons dans le monde et notre ont un impact positif énorme sur la vie.

Nous avons besoin de plus de gens sont intéressés, plus de cours, plus professionnels, plus enthousiastes. Nous avons besoin de vous :)

Merci de lire ceci, je l'espère, vous trouverez ici est plus intéressant :)

Si vous avez des questions, s'il vous plaît me contacter sur Twitter et LinkedIn:

• gazouillement

  Favio Vázquez (@FavioVaz)

• LinkedIn:

  Favio Vázquez - Scientifique principal de données - OXXO | LinkedIn