A gépi tanulás, a számítógépes látás, a hatékony API-k építése és a gyönyörű felhasználói felület létrehozása izgalmas területek, amelyek sok újításnak tanúskodnak.

Az első kettő kiterjedt matematikát és természettudományt igényel, míg az API és az UI fejlesztési központja az algoritmikus gondolkodás és a rugalmas architektúrák megtervezése. Nagyon különböznek egymástól, ezért nehéz eldönteni, hogy melyiket akarja megtanulni legközelebb. A cikk célja annak bemutatása, hogy mind a négyen hogyan alkalmazhatók egy képfeldolgozó alkalmazás létrehozásában.

Az alkalmazás, amelyet fel fogunk építeni, egy egyszerű számjegy-felismerő. Rajzol, a gép megjósolja a számjegyet. Az egyszerűség elengedhetetlen, mert ez lehetővé teszi számunkra, hogy a nagy képet lássuk, nem pedig a részletekre.

Az egyszerűség kedvéért a legnépszerűbb és könnyen elsajátítható technológiákat fogjuk használni. A gépi tanulás része használni fogja Piton háttér-alkalmazáshoz. Ami az alkalmazás interakciós oldalát illeti, egy JavaScript könyvtáron keresztül fogunk működni, amely nem igényel bevezetést: Reagál .

mennyibe kerül egy bloomberg terminál havonta

Gépi tanulás kitalálni a számokat

Alkalmazásunk központi része a rajzolt számot kitaláló algoritmus. A gépi tanulás lesz az az eszköz, amelyet a jó tippminőség eléréséhez használnak. Ez a fajta alapvető mesterséges intelligencia lehetővé teszi a rendszer számára, hogy adott mennyiségű adattal automatikusan tanuljon. Tágabb értelemben a gépi tanulás olyan folyamat, amelynek során véletlen vagy véletlenek halmazát találják meg az adatokban, hogy rájuk támaszkodjanak az eredmény kitalálásában.

Képfelismerési folyamatunk három lépést tartalmaz:

• Képeket készíthet a rajzolt számjegyekről a képzéshez
• Képezze a rendszert arra, hogy képzési adatok alapján kitalálja a számokat
• Tesztelje a rendszert új / ismeretlen adatokkal

Környezet

Szükségünk lesz egy virtuális környezet gépi tanulással dolgozni a Pythonban. Ez a megközelítés praktikus, mert az összes szükséges Python-csomagot kezeli, így nem kell aggódnia miattuk.

Telepítsük a következő terminálparancsokkal:

python3 -m venv virtualenv source virtualenv/bin/activate

Képzési modell

Mielőtt elkezdenénk írni a kódot, ki kell választanunk egy megfelelő „tanárt” a gépeinkhez. Általában az adattudomány szakemberei különböző modelleket próbálnak ki, mielőtt kiválasztják a legjobbat. Kihagyunk nagyon fejlett, sok készséget igénylő modelleket, és folytatjuk a k-legközelebbi szomszédok algoritmusa .

Ez egy algoritmus, amely összegyűjt néhány adatmintát, és elrendezi azokat egy adott jellemzők által rendezett síkon. Hogy jobban megértsük, nézzük át a következő képet:

A Zöld Pont , ellenőriznünk kell a típusokat nak nek legközelebbi szomszédok hol nak nek az argumentumkészlet. Figyelembe véve a fenti képet, ha nak nek értéke 1, 2, 3 vagy 4, a találgatás a lesz Fekete háromszög mint a legtöbb zöld pont legközelebb nak nek a szomszédok fekete háromszögek. Ha növeljük nak nek 5-ig, akkor az objektumok többsége kék négyzet, ezért a találgatás a Kék tér .

A gépi tanulási modell létrehozásához néhány függőség szükséges:

• sklearn.neighbors.KNeighborsClassifier az osztályozó, amelyet használni fogunk.
• sklearn.model_selection.train_test_split az a funkció, amely segít az adatok felosztására edzésadatokra és a modell helyességének ellenőrzésére használt adatokra.
• sklearn.model_selection.cross_val_score az a funkció, hogy jelet kapjunk a modell helyességéről. Minél nagyobb az érték, annál jobb a helyesség.
• sklearn.metrics.classification_report az a funkció, amely statisztikai jelentést mutat a modell találgatásairól.
• sklearn.datasets az a csomag, amellyel adatokat szereznek a képzéshez (számjegyek képei).
• számtalan egy olyan csomag, amelyet a tudományban széles körben használnak, mivel produktív és kényelmes módszert kínál a többdimenziós adatszerkezetek manipulálására a Pythonban.
• matplotlib.pyplot az adatok vizualizálására használt csomag.

Kezdjük mindegyik telepítésével és importálásával:

pip install sklearn numpy matplotlib scipy from sklearn.datasets import load_digits from sklearn.neighbors import KNeighborsClassifier from sklearn.model_selection import train_test_split, cross_val_score import numpy as np import matplotlib.pyplot as plt

Most be kell töltenünk a MNIST adatbázis . Az MNIST egy kézzel írott képek klasszikus adatkészlete, amelyet kezdők ezrei használnak a gépi tanulás területén:

digits = load_digits()

Miután az adatok be lettek töltve és elkészültek, áttérhetünk az adatok két részre bontásának következő lépésére: kiképzés és tesztelés .

Az adatok 75% -át felhasználjuk a modellünk kitalálására számjegyek kitalálására, a többi adatot pedig a modell helyességének tesztelésére:

(X_train, X_test, y_train, y_test) = train_test_split( digits.data, digits.target, test_size=0.25, random_state=42 )

Az adatok el vannak rendezve, és készen állunk felhasználásra. Megpróbáljuk megtalálni a legjobb paramétert nak nek modellünkhöz, így a találgatások pontosabbak lesznek. Nem tudjuk megtartani a nak nek értékelje le a fejünket ebben a szakaszban, mivel mással kell értékelnünk a modellt nak nek értékek.

Lássuk, miért elengedhetetlen figyelembe venni egy tartományt nak nek értékeket és hogyan javítja ez modellünk pontosságát:

ks = np.arange(2, 10) scores = [] for k in ks: model = KNeighborsClassifier(n_neighbors=k) score = cross_val_score(model, X_train, y_train, cv=5) score.mean() scores.append(score.mean()) plt.plot(scores, ks) plt.xlabel('accuracy') plt.ylabel('k') plt.show()

Ennek a kódnak a végrehajtása megmutatja a következő diagramot, amely az algoritmus pontosságát különböző módon írja le nak nek értékek.

Mint láthatja, a nak nek A 3 érték biztosítja a legjobb pontosságot modellünk és adatkészletünk számára.

Lombik használata API létrehozásához

Az alkalmazásmag, amely egy algoritmus, amely a számjegyeket megjósolja a képekből, most készen áll. Ezután meg kell díszítenünk az algoritmust egy API réteggel, hogy elérhetővé váljon a használat céljából. Használjuk a népszerűt Lombik webes keretrendszer hogy ezt tisztán és tömören tegyem.

Először a Flask és a képfeldolgozással kapcsolatos függőségek telepítésével kezdjük a virtuális környezetben:

pip install Flask Pillow scikit-image

Amikor a telepítés befejeződött, az alkalmazás belépési pontjának létrehozásához lépünk:

touch app.py

A fájl tartalma így fog kinézni:

import os from flask import Flask from views import PredictDigitView, IndexView app = Flask(__name__) app.add_url_rule( '/api/predict', view_func=PredictDigitView.as_view('predict_digit'), methods=['POST'] ) app.add_url_rule( '/', view_func=IndexView.as_view('index'), methods=['GET'] ) if __name__ == 'main': port = int(os.environ.get('PORT', 5000)) app.run(host='0.0.0.0', port=port)

Hibaüzenetet kap, amikor azt mondja, hogy PredictDigitView és IndexView nincsenek meghatározva. A következő lépés egy fájl létrehozása, amely inicializálja ezeket a nézeteket:

from flask import render_template, request, Response from flask.views import MethodView, View from flask.views import View from repo import ClassifierRepo from services import PredictDigitService from settings import CLASSIFIER_STORAGE class IndexView(View): def dispatch_request(self): return render_template('index.html') class PredictDigitView(MethodView): def post(self): repo = ClassifierRepo(CLASSIFIER_STORAGE) service = PredictDigitService(repo) image_data_uri = request.json['image'] prediction = service.handle(image_data_uri) return Response(str(prediction).encode(), status=200)

Ismét hibát fogunk tapasztalni egy megoldatlan import kapcsán. Az Nézetek A csomag három fájlra támaszkodik, amelyek még nincsenek:

• Beállítások
• Repo
• Szolgáltatás

Egyenként fogjuk megvalósítani őket.

Beállítások konfigurációkkal és állandó változókkal rendelkező modul. Tárolja számunkra a sorosított osztályozó elérési útját. Logikus kérdést vet fel: Miért kell elmentenem az osztályozót?

Mert ez egy egyszerű módszer az alkalmazás teljesítményének javítására. Ahelyett, hogy minden alkalommal megkérnénk az osztályozót arra, hogy megkeresést kapjon, eltároljuk az osztályozó előkészített verzióját, lehetővé téve a dobozból történő munkát:

import os BASE_DIR = os.getcwd() CLASSIFIER_STORAGE = os.path.join(BASE_DIR, 'storage/classifier.txt')

A beállítások mechanizmusát - az osztályozó megszerzését - a listánk következő csomagja, a Repo . Ez egy osztály két módszerrel a képzett osztályozó lekérésére és frissítésére a Python beépített pickle segítségével modul:

import pickle class ClassifierRepo: def __init__(self, storage): self.storage = storage def get(self): with open(self.storage, 'wb') as out: try: classifier_str = out.read() if classifier_str != '': return pickle.loads(classifier_str) else: return None except Exception: return None def update(self, classifier): with open(self.storage, 'wb') as in_: pickle.dump(classifier, in_)

Közel vagyunk az API-nk véglegesítéséhez. Most már csak a Szolgáltatás modul. Mi a célja?

aws Solutions építész munkatárs tanulmányi útmutató

• Szerezze be a betanított osztályozót a tárolóból
• Alakítsa át a felhasználói felületről továbbított képet egy olyan formátumba, amelyet az osztályozó ért
• Számítsa ki az előrejelzést a formázott képpel az osztályozón keresztül
• Adja vissza az előrejelzést

Kódoljuk ezt az algoritmust:

from sklearn.datasets import load_digits from classifier import ClassifierFactory from image_processing import process_image class PredictDigitService: def __init__(self, repo): self.repo = repo def handle(self, image_data_uri): classifier = self.repo.get() if classifier is None: digits = load_digits() classifier = ClassifierFactory.create_with_fit( digits.data, digits.target ) self.repo.update(classifier) x = process_image(image_data_uri) if x is None: return 0 prediction = classifier.predict(x)[0] return prediction

Itt láthatja, hogy PredictDigitService két függősége van: ClassifierFactory és process_image.

Kezdjük azzal, hogy létrehozunk egy osztályt a modellünk létrehozásához és kiképzéséhez:

from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier class ClassifierFactory: @staticmethod def create_with_fit(data, target): model = KNeighborsClassifier(n_neighbors=3) model.fit(data, target) return model

Az API készen áll a cselekvésre. Most folytathatjuk a képfeldolgozási lépést.

Képfeldolgozás

A képfeldolgozás egy bizonyos műveletek végrehajtásának módja a képen annak javítása vagy hasznos információk kinyerése céljából. Esetünkben simán át kell váltanunk a felhasználó által rajzolt képet a gépi tanulási modell formátumra.

Importáljunk néhány segítőt e cél elérése érdekében:

import numpy as np from skimage import exposure import base64 from PIL import Image, ImageOps, ImageChops from io import BytesIO

Az átmenetet hat külön részre oszthatjuk fel:

1. Cserélje az átlátszó hátteret színre

def replace_transparent_background(image): image_arr = np.array(image) if len(image_arr.shape) == 2: return image alpha1 = 0 r2, g2, b2, alpha2 = 255, 255, 255, 255 red, green, blue, alpha = image_arr[:, :, 0], image_arr[:, :, 1], image_arr[:, :, 2], image_arr[:, :, 3] mask = (alpha == alpha1) image_arr[:, :, :4][mask] = [r2, g2, b2, alpha2] return Image.fromarray(image_arr)

2. Vágja le a határokat

def trim_borders(image): bg = Image.new(image.mode, image.size, image.getpixel((0,0))) diff = ImageChops.difference(image, bg) diff = ImageChops.add(diff, diff, 2.0, -100) bbox = diff.getbbox() if bbox: return image.crop(bbox) return image

3. Adjon hozzá azonos méretű szegélyeket

def pad_image(image): return ImageOps.expand(image, border=30, fill='#fff')

4. Konvertálja a képet szürkeárnyalatos módba

def to_grayscale(image): return image.convert('L')

5. Fordítsa meg a színeket

def invert_colors(image): return ImageOps.invert(image)

6. Átméretezze a képet 8x8 formátumra

def resize_image(image): return image.resize((8, 8), Image.LINEAR)

Most tesztelheti az alkalmazást. Futtassa az alkalmazást, és írja be az alábbi parancsot, amellyel kérelmet szeretne küldeni ezt az iStock képet az API-hoz:

php 7 visszafelé kompatibilis

export FLASK_APP=app flask run curl 'http://localhost:5000/api/predict' -X 'POST' -H 'Content-Type: application/json' -d ' base64)'' -i

A következő kimenetet kell látnia:

HTTP/1.1 100 Continue HTTP/1.0 200 OK Content-Type: text/html; charset=utf-8 Content-Length: 1 Server: Werkzeug/0.14.1 Python/3.6.3 Date: Tue, 27 Mar 2018 07:02:08 GMT 8

A mintakép a 8. számot ábrázolta, és alkalmazásunk helyesen azonosította.

Rajzpanel létrehozása a React segítségével

A frontend alkalmazás gyors indításához használjuk CRA kazán :

create-react-app frontend cd frontend

A munkahely beállítása után függőségre is szükségünk van a számjegyek rajzolásához. Az reagál-vázlat csomag tökéletesen megfelel igényeinknek:

npm i react-sketch

Az alkalmazásnak csak egy összetevője van. Ezt az összetevőt két részre oszthatjuk: logika és nézet .

hány társkereső alkalmazás van

A nézet része felelős a rajz ablaktábla képviseletéért, Beküldés és Visszaállítás gombok. Ha kölcsönhatásba lépünk, akkor jóslatot vagy hibát is kell ábrázolnunk. Logikai szempontból a következő feladatai vannak: küldjön be képeket és törölje a vázlatot .

Amikor egy felhasználó rákattint Beküldés , az összetevő kibontja a képet a vázlat összetevőből, és fellebbez az API modul makePrediction funkció. Ha a háttérbe történő kérés sikeres, beállítjuk az előrejelzési állapot változót. Ellenkező esetben frissítjük a hiba állapotát.

Amikor a felhasználó rákattint Visszaállítás , a vázlat törli:

import React, { useRef, useState } from 'react'; import { makePrediction } from './api'; const App = () => { const sketchRef = useRef(null); const [error, setError] = useState(); const [prediction, setPrediction] = useState(); const handleSubmit = () => { const image = sketchRef.current.toDataURL(); setPrediction(undefined); setError(undefined); makePrediction(image).then(setPrediction).catch(setError); }; const handleClear = (e) => sketchRef.current.clear(); return null }

A logika elegendő. Most hozzáadhatjuk hozzá a vizuális felületet:

import React, { useRef, useState } from 'react'; import { SketchField, Tools } from 'react-sketch'; import { makePrediction } from './api'; import logo from './logo.svg'; import './App.css'; const pixels = (count) => `${count}px`; const percents = (count) => `${count}%`; const MAIN_CONTAINER_WIDTH_PX = 200; const MAIN_CONTAINER_HEIGHT = 100; const MAIN_CONTAINER_STYLE = { width: pixels(MAIN_CONTAINER_WIDTH_PX), height: percents(MAIN_CONTAINER_HEIGHT), margin: '0 auto', }; const SKETCH_CONTAINER_STYLE = { border: '1px solid black', width: pixels(MAIN_CONTAINER_WIDTH_PX - 2), height: pixels(MAIN_CONTAINER_WIDTH_PX - 2), backgroundColor: 'white', }; const App = () => { const sketchRef = useRef(null); const [error, setError] = useState(); const [prediction, setPrediction] = useState(); const handleSubmit = () => { const image = sketchRef.current.toDataURL(); setPrediction(undefined); setError(undefined); makePrediction(image).then(setPrediction).catch(setError); }; const handleClear = (e) => sketchRef.current.clear(); return ( {prediction &&

Predicted value is: {prediction}

} Clear Guess the number {error &&

Something went wrong

} ); }; export default App;

A komponens készen áll, tesztelje futtatással és lépjen a localhost:3000 után:

npm run start

A demo alkalmazás elérhető itt . A forráskódban is böngészhet GitHub .

Csomagolás

Ennek az osztályozónak a minősége nem tökéletes, és nem teszek úgy, mintha az lenne. Óriási a különbség a képzéshez használt adatok és a felhasználói felületről származó adatok között. Ennek ellenére kevesebb mint 30 perc alatt létrehoztunk egy működő alkalmazást a semmiből.

Ennek során négy területen csiszoltuk képességeinket:

• Gépi tanulás
• Háttér-fejlesztés
• Képfeldolgozás
• Frontend fejlesztés

Nincs hiány a kézírásos számjegyek felismerésére alkalmas szoftverek esetleges felhasználási eseteiben, az oktatási és adminisztrációs szoftverektől a postai és pénzügyi szolgáltatásokig.

Ezért remélem, hogy ez a cikk arra ösztönzi Önt, hogy fejlessze gépi tanulási képességeit, képfeldolgozását, valamint kezelőfelületének és háttértámogatásának fejlesztését, és ezeket a készségeket felhasználja csodálatos és hasznos alkalmazások tervezéséhez.

Ha bővíteni szeretné a gépi tanulás és a képfeldolgozás ismereteit, érdemes megnéznie a mi oldalunkat Versenyképes gépi tanulás bemutatója .

Az alapok megértése

Mi az MNIST a gépi tanulásban?

Az MNIST az egyik legnépszerűbb belépő szintű adatkészlet a számítógépes látás terén. Több ezer képet tartalmaz kézzel írott számjegyekről.

Mi a képzés a gépi tanulásban?

A gépi tanulási modellek tanulnak az adatokból. Ahhoz, hogy a modell elég okos legyen, meg kell adnunk a rendelkezésre álló adatokat a várt eredményekkel. A modell ezeket az adatokat felhasználja az adatparaméterek és a kívánt eredmény közötti összefüggések felderítésére.

Mi a képfeldolgozás a gépi tanulásban?

A képfeldolgozás olyan módszer, amellyel bizonyos műveleteket hajthat végre egy képpel, hogy továbbfejlesztett képet kapjon, vagy hasznos információkat nyerjen ki.