Viac

Použitím Pythonu výstup Batch Project neklesne do množiny dát funkcií?

Použitím Pythonu výstup Batch Project neklesne do množiny dát funkcií?


Pri pokuse o dávkový projekt v ArcGIS 9.3 alebo 10 (pomocou arcpy alebo arcgisscripting) nemôžem dosiahnuť, aby moje výsledky geografického spracovania spadli do súboru údajov o vlastnostiach, ktorý zadám. Výsledky sa namiesto toho umiestnia do koreňového adresára geodatabázy (* .mdb).

Tu je skrátená verzia toho, čo zatiaľ mám:

import arcgisscripting, os gp = arcgisscripting.create (9.3) #set date dmy = datetime.now () currentDate = str (dmy.month) + "-" + str (dmy.day) + "-" + str (dmy. rok) outputfolder = gp.getparameterastext (0) # kde umiestnime gdb citydata = gp.getparameterastext (1) gp.workspace = outputfolder projectedfolder = os.path.join (outputfolder, "projected") gp.CreateFolder_management (* os.path.split (projectedfolder)) gdb = "Projected_Data_" + currentDate + ".mdb" #set coordinate system outputCS = gp.CreateObject ("SpatialReference") outputCS.createFromFile (os.path.join (gp.getinstallinfo) () ['InstallDir'], "Coordinate Systems  Geographic Coordinate Systems  North America  NAD 1983.prj")) transformation = "" gp.AddMessage ("Vytvorenie množiny údajov o funkcii mesta") gp.CreateFeatureDataset (os. path.join (projectedfolder, gdb), "City", outputCS) gp.AddMessage ("Načítanie v triedach funkcií mesta") arcpy.BatchProject_management (citydata, os.path.join (projectedfolder, gdb, "City"), outputCS, „“, transformácia)

Je zrejmé, že časťou, s ktorou mám problémy, je Výstupná cesta v poslednom riadku. Tiež som naprogramoval cestu k množine údajov „City“, ale stále ju vkladám do koreňového adresára. Nejaké nápady?

(Krížovo uverejnené na fórach ESRI tu)


Mnoho ľudí sa na to pýtalo. Aspoň jedna žiadosť (NIM013677) bola odmietnutá so stavom „ako bolo navrhnuté“. Uvádzaný dôvod je:

Pretože pri použití verzie skriptu nemôže nástroj vedieť, či je cieľom množina údajov alebo trieda prvkov. Je navrhnutý tak, aby nepodporoval množinu údajov o vlastnostiach.

Štandardné zrieknutie sa zodpovednosti: Pracujem v spoločnosti Esri, ale nie v tíme pre geoprocesiu (ktorý sa rozhodol).


To je opravené v ArcGIS 10.1: http://forums.arcgis.com/threads/39448-Using-Python-can-t-get-Batch-Project-outputs-to-save-in-a-feature-dataset?p = 244841 & viewfull = 1 # post244841

Testoval som to v okne Pythonu v ArcMap 10.1, funguje to :-)


V celej dokumentácii predpokladáme, že ju používate virtualenv na správu vašich prostredí Pythonu. Toto nastavenie je nastavenie, ktoré používajú a odporúčajú autori projektu, a je najjednoduchším spôsobom, ako sa ubezpečiť, že nenarazíte na problémy so životným prostredím. Ak používate Anakonda, Miniconda alebo Mamba, najskôr si prečítajte pokyny na stránke Training from an Anaconda or miniconda environment and then continue from the installation step below.

Pri vytváraní virtuálneho prostredia vytvoríte adresár obsahujúci binárny súbor python3 a všetko potrebné na spustenie deepspeech. Môžete použiť ľubovoľný adresár, ktorý chcete. Pre účely dokumentácie sa budeme spoliehať na $ HOME / tmp / deepspeech-train-venv. Môžete ho vytvoriť pomocou tohto príkazu:

Po úspešnom dokončení tohto príkazu bude prostredie pripravené na aktiváciu.


Úvod

Pre tých, ktorí začínajú v prostredí Optical Character Recognition (OCR), považujem za zaujímavé uviesť krátky kontext.

Podľa [1] majú systémy OCR dve kategórie: online, v ktorých sa vstupné informácie získavajú prostredníctvom senzorov zápisu v reálnom čase a offline, v ktorom sa vstupné informácie získavajú prostredníctvom statických informácií (obrázkov). V rámci offline kategórii je rozpoznávanie strojopisného a rukopisného textu (obrázok 1).

Účelom rozpoznávania ručne písaného textu (HTR) je teda účel prepisu kurzívneho textu na digitálne médium (ASCII, Unicode) [2].

Systémy HTR už mnoho rokov používajú pre úlohu transkripcie modely skrytých Markovovcov (HMM) [3] - [5], ale nedávno sa prostredníctvom Deep Learning na prekonanie niektorých obmedzení použil prístup Convolutional Recurrent Neural Network (CRNN). HMM [6], [7]. Na ilustráciu modelu CRNN prinášam model [8] (obrázok 2).

Pracovný postup je možné rozdeliť do 3 krokov. Krok 1: vstupný obraz sa privádza do vrstiev CNN na extrahovanie funkcií. Výstupom je mapa funkcií. Krok 2: implementáciou Long Short-Term Memory (LSTM) je RNN schopná šíriť informácie na väčšie vzdialenosti a poskytovať výcvikom robustnejšie funkcie. Krok 3: s výstupnou maticou RNN vypočítava Connectionist Temporal Classification (CTC) [9] hodnotu straty a tiež dekóduje do konečného textu.

Pre viac podrobností o tomto procese odporúčam prečítať Vytvorte systém rozpoznávania rukopisného textu pomocou TensorFlow autor: Harald Scheidl (2018).

Nakoniec je veľmi dôležité vysvetliť, že pre tento post, krok 3 (CTC) je rovnaký pre všetky prezentované architektúry, potom sa použije metóda Vanilla Beam Search [10], pretože na svoju aplikáciu nevyžaduje slovník, na rozdiel od iných známych metód, ako napríklad Token Passing [11] a Vyhľadávanie lúča slova [8]. Architektúry uvedené v nasledujúcich častiach preto konajú iba v krokoch 1 a 2.

Okrem toho znaková sada pre kódovanie textu je rovnako rovnaký pre všetky súbory údajov. Použitý zoznam teda predvolene pozostáva z 95 tlačiteľných znakov z tabuľky ASCII (obrázok 3) a neobsahuje písmená s diakritikou.

Možno by vás zaujímalo, prečo používať rovnaký CTC a znakovú sadu pre architektúry a súbory údajov. Pre tento cieľavedomý experiment som chcel priniesť jednotnejší prístup medzi modelmi a databázami. Pretože použitie konkrétnych slovníkov a znakových skupín môže v niektorých scenároch priniesť lepšie výsledky, v iných nie až tak veľmi. Napríklad znaková sada s iba 60 znakmi je „ľahšie zasiahnuteľná“ (1/60) ako iná so znakom 125 (1/125). Tento prístup sa v skutočnosti stáva pre modely rozpoznávaním textu ťažší.


Definujte funkciu skóre anomálie

Ďalej musíme definovať funkciu, ktorá počíta, ako neobvyklé sú jednotlivé transakcie. Čím je transakcia anomálnejšia, tým je pravdepodobnejšie, že bude podvodná, za predpokladu, že podvod je zriedkavý a vyzerá trochu inak ako väčšina transakcií, ktoré sú bežné.

Ako sme diskutovali v predchádzajúcej kapitole, algoritmy znižovania rozmerov znižujú rozmernosť údajov pri pokuse o minimalizáciu chyby rekonštrukcie. Inými slovami, tieto algoritmy sa snažia zachytiť najvýznamnejšie informácie o pôvodných znakoch takým spôsobom, aby mohli čo najlepšie rekonštruovať pôvodný súbor znakov z redukovanej sady znakov. Avšak tieto algoritmy znižovania rozmerov nemôžu zachytiť všetky informácie o pôvodných znakoch pri ich prechode do nižšieho dimenzionálneho priestoru, a preto dôjde k určitej chybe, pretože tieto algoritmy rekonštruujú redukovaný znak nastavený späť na pôvodný počet rozmerov.

V kontexte nášho súboru údajov o transakciách s kreditnými kartami budú mať algoritmy najväčšiu chybu rekonštrukcie pri tých transakciách, ktoré sa najťažšie modelujú - inými slovami pri tých, ktoré sa vyskytujú najmenej často a sú najbežnejšie. Pretože podvody sú zriedkavé a pravdepodobne odlišné od bežných transakcií, mali by podvodné transakcie vykazovať najväčšiu chybu pri rekonštrukcii. Definujme teda skóre anomálie ako chybu rekonštrukcie. Chyba rekonštrukcie pre každú transakciu je súčtom štvorcových rozdielov medzi pôvodnou maticou znakov a rekonštruovanou maticou pomocou algoritmu redukcie rozmerov. Zmenšíme súčet štvorcových rozdielov o rozsah max-min súčtu štvorcových rozdielov pre celú množinu údajov tak, aby všetky chyby rekonštrukcie boli v rozmedzí od nuly do jedného.

Transakcie, ktoré majú najväčší súčet štvorcových rozdielov, budú mať chybu blízku jednej, zatiaľ čo tie, ktoré majú najmenší súčet štvorcových rozdielov, budú mať chybu blízku nule.

Toto by malo byť známe. Rovnako ako riešenie na detekciu podvodov pod dohľadom, ktoré sme vytvorili v kapitole 2, bude algoritmus znižovania rozmerov efektívne priraďovať každej transakcii skóre anomálie medzi nulou a jednou. Nula je normálna a jedna je anomálna (a s najväčšou pravdepodobnosťou bude podvodná).


Použitím Pythonu výstup Batch Project neklesne do množiny dát funkcií? - Geografické informačné systémy

Automatizované inžinierstvo funkcií a skórovanie modelov pomocou IBM Watson Studio Local

Cieľom tohto kódu je demonštrovať, ako môžu dátoví vedci využiť Watson Studio Local od spoločnosti IBM na automatizáciu:

Periodická extrakcia funkcií (používa sa na trénovanie modelu strojového učenia) z distribuovaných súborov údajov.

Dávkové skórovanie extrahovaných funkcií nasadeného modelu.

Na ilustráciu je v tomto vzorovom kóde použitý príklad pracovného toku dátovej vedy, ktorý klasifikuje 3 rôzne kategórie vín z chemických vlastností týchto vín.

Pri extrakcii znakov sa na súbor údajov o klasifikácii vín aplikuje analýza hlavných komponentov (PCA) a extrahujú sa dva hlavné komponenty.

Pre klasifikačný model sa na extrahované komponenty použije logistická regresia (populárny model strojového učenia) na predpovedanie kategórií vín.

Čo je to PCA? Analýza hlavných komponentov (PCA) je populárna technika redukcie rozmerov, ktorá sa používa na zníženie počtu N numerických premenných na niekoľko hlavných komponentov, ktoré sa používajú ako prvky v modeli strojového učenia. Tieto hlavné komponenty zachytávajú hlavné percento účinku kombinovanej odchýlky všetkých premenných.

Čo je IBM Watson Studio Local? Watson Studio Local je lokálne riešenie pre dátových vedcov a dátových inžinierov. Ponúka sadu nástrojov na vedeckú prácu s údajmi, ktoré sa integrujú s technológiami notebookov RStudio, Spark, Jupyter a Zeppelin.

Čo je IBM Watson Machine Learning? Watson Machine Learning je miestny nástroj Watson Studio, ktorý používateľom umožňuje vytvárať a trénovať modely strojového učenia. Používatelia môžu tiež nasadiť svoje modely a sprístupniť ich širšiemu publiku.

Toto repo obsahuje dva notebooky Jupyter ilustrujúce, ako extrahovať funkcie a zostaviť model na množine údajov klasifikácie vín. Údaje obsahujú zoznam vín s príslušnými chemickými vlastnosťami a priradenou klasifikáciou vín. V repo sú tri skripty, ktoré automatizujú extrakciu funkcií, skóre extrahovaných funkcií a kombinujú dva kroky ako jeden obal.

Prvý notebook využíva techniky inžinierstva funkcií, ako je PCA a štandardné škálovanie, na extrahovanie funkcií pre vývoj modelu z množiny údajov o víne.

Druhý notebook trénuje, zostavuje a ukladá model, ktorý je možné skórovať. Model je potom možné nasadiť a získať k nemu vzdialený prístup.

Prvý skript je jednoducho replikou prvého poznámkového bloku ako skript .py, ktorý je možné naplánovať na pravidelné extrahovanie funkcií a ich ukladanie s číslami verzií.

Druhý skript sa používa na skórovanie množiny extrahovaných funkcií nasadeného modelu a na uloženie výsledkov s verziou verzií.

Tretí skript je jednoducho súhrnný skript, ktorý spúšťa dva vyššie uvedené skripty jeden za druhým a slúži na automatizáciu extrakcie funkcií a skórovania modelu v jednom behu.

Pomocou funkcie Watson Machine Learning vo Watson Studio sú všetky tri skripty nasadené ako služba na automatizáciu extrakcie funkcií a skórovania v produkcii.

Keď dokončíte tento vzor kódu, pochopíte, ako:

  • Použite program Watson Studio Local a na extrahovanie funkcií pomocou PCA a iných techník.
  • Zostavte, trénujte a uložte model z extrahovaných funkcií pomocou programu Watson Studio Local.
  • Použite funkciu Watson Machine Learning na nasadenie a prístup k vášmu modelu v dávkovom režime a rozhraní API
  • Automatizujte extrakciu funkcií a skórovanie modelov pomocou skriptov, ktoré sú nasadené ako služba v dávkovom režime a režime API.

  1. Sada údajov o klasifikácii vín sa načíta do produktu Watson Studio Local ako majetok.
  2. Užívateľ interaguje s programom Watson Studio Local a získava prístup k prostriedkom, ako sú notebooky Jupyter, skripty python a súbory údajov.
  3. Notebooky Jupyter používajú operácie Spark DataFrame na vyčistenie množiny údajov a na trénovanie modelu klasifikácie PCA používajú Spark MLlib.
  4. Model a sprievodné skripty sa nasadzujú a spúšťajú z programu Watson Machine Learning.
    : Pripravené miestne riešenie pre dátových vedcov a dátových inžinierov. Ponúka sadu nástrojov na vedeckú prácu s údajmi, ktoré sa integrujú s technológiami notebookov RStudio, Spark, Jupyter a Zeppelin. : Open-source, rýchly a univerzálny klastrový výpočtový systém. : Open-source webová aplikácia, ktorá vám umožňuje vytvárať a zdieľať dokumenty, ktoré obsahujú živý kód, rovnice, vizualizácie a vysvetľujúci text.
    : Umelá inteligencia sa môže použiť na nesúrodé priestory riešení na dodanie rušivých technológií. : Python je programovací jazyk, ktorý vám umožní pracovať rýchlejšie a efektívnejšie integrovať vaše systémy.

Nainštalujte si Watson Studio Local

Watson Studio Local poskytuje sadu nástrojov na vedeckú prácu s údajmi, ako sú notebooky Spark a Jupyter, ktoré sú potrebné na dokončenie tohto kódu. Prečítajte si inštalačnú príručku a nainštalujte a nakonfigurujte svoju inštanciu Watson Studio Local.

Podľa týchto pokynov nastavíte správne prostredie na miestne spustenie našich notebookov.

2. Vytvorte projekt v IBM Watson Studio Local Local

Vo Watson Studio Local používame projekty ako kontajner pre všetky naše súvisiace aktíva. Vytvorenie projektu:

Po vytvorení môžete zobraziť všetky aktíva projektu výberom karty Aktíva na domovskej stránke projektu.

Pre náš projekt musíme pridať naše zošity a skripty. Ak chcete pridať naše zošity:

V zozname Diela projektu vyberte Poznámkové bloky a potom stlačte tlačidlo Pridať poznámkový blok.

Zadajte jedinečný názov poznámkového bloku a pomocou možnosti Od URL načítajte poznámkový blok z úložiska github.

Vyberte prostredie, ktoré beží pod Python v3.1 alebo novším.

POZNÁMKA: Aby ste uľahčili vykonávanie zvyšných pokynov, odporúča sa nastaviť názov tak, aby sa zhodoval s názvom poznámkového bloku v nahranom súbore.

  • Kliknite na kartu Od súboru a potom pomocou možnosti Drag and Drop načítajte súbor skriptu z miestneho úložiska. Názov skriptu bude vopred vyplnený názvom nahraného súboru. Vyberte Python verzie 3.

Na karte Miestny súbor kliknite na tlačidlo Vybrať z miestneho systému súborov a vyberte súbor /data/Wine.csv z miestneho úložiska.

4. Spustením notebookov vytvorte náš model

Ak si chcete pozrieť naše poznámkové bloky, vyberte v zozname Aktíva projektu Poznámkové bloky.

Najprv niekoľko informácií o tom, ako vykonávať notebooky:

  • Prázdne miesto, čo znamená, že bunka nikdy nebola vykonaná.
  • Číslo, toto číslo predstavuje relatívne poradie, v ktorom bol vykonaný tento krok kódu.
  • *, Čo znamená, že bunka sa práve vykonáva.
  • Po jednej bunke.
    • Vyberte bunku a potom stlačte tlačidlo Prehrať na paneli nástrojov.
    • Na paneli ponuky Bunka je k dispozícii niekoľko možností. Môžete napríklad spustiť všetky bunky v notebooku alebo Spustiť všetky nižšie, ktoré sa začnú spúšťať z prvej bunky v aktuálne vybranej bunke a potom budú pokračovať vo vykonávaní všetkých nasledujúcich buniek.
    • Stlačte tlačidlo Naplánovať umiestnené v pravej hornej časti panela notebooku. Tu môžete naplánovať spustenie vášho notebooku raz v budúcnosti alebo opakovane v zadanom intervale.

    Ak chcete spustiť poznámkový blok, jednoducho kliknite na názov poznámkového bloku v zozname Poznámkové bloky.

    Najskôr spustite notebook s funkciami pca. Číta a transformuje súbor údajov o víne. Vytvára tiež dátové súbory, ktoré bude vyžadovať nasledujúci poznámkový blok. Tieto dátové súbory vo formáte CSV je možné zobraziť výberom položky Dátové sady v zozname Projektové aktíva.

    Spustite notebook na modelovanie pca, ktorý generuje a ukladá náš dátový model.

    Po vytvorení modelu ho môžete zobraziť výberom položky Modely v zozname Projektové aktíva. Upozorňujeme, že má predvolené číslo verzie.

    Poznámka: Po vykonaní poznámkových blokov by vás mohlo zaujímať, prečo sme nekombinovali celý kód do jediného poznámkového bloku. Dôvodom je jednoducho oddeliť kroky spracovania údajov od krokov vytvárania modelu. To nám umožňuje v budúcnosti spracovávať akékoľvek nové údaje bez ovplyvnenia nášho súčasného modelu. V skutočnosti je to presne to, čo by sa malo urobiť s akýmikoľvek novými údajmi - najskôr ich porovnajte so súčasným modelom a zistite, či sú výsledky stále prijateľné. Ak nie, môžeme spustiť druhý notebook a vygenerovať nový model.

    Ako uvidíte neskôr, spustenie prvého poznámkového bloku sa uskutoční spustením skriptu v našom projekte (scripts / feature_engineering.py). Tento skript bol pôvodne vytvorený načítaním notebooku pca-features do Jupyteru a následným exportom buniek notebooku do skriptu python (použite možnosti ponuky File - & gt Download as - & gt Python (.py)). Len sme museli mierne upraviť skript tak, aby obsahoval nejaký kód na spracovanie verzií údajov.

    5. Potvrďte zmeny v lokálnom hlavnom úložisku Watson Studio

    Po vykonaní zmien vo vašom projekte vám bude občas pripomenuté, aby ste sa zaviazali a preniesli vaše zmeny do lokálneho hlavného úložiska Watson Studio.

    Teraz, keď sme pridali naše notebooky a skripty a vygenerovali náš model, poďme do toho. Zaviažte a zatlačte všetky naše nové diela a nastavte značku verzie na v1.0.

    6. Vytvorte projekt vydania v IBM Watson Machine Learning

    IBM Watson Machine Learning poskytuje mechanizmus na nasadenie nášho modelu ako webovej služby. Spravuje vydania projektu, ktoré teraz vytvoríme.

    • Spustite nástroj IBM Watson Machine Learning tak, že ho vyberiete z hlavnej rozbaľovacej ponuky na domovskej stránke programu Watson Studio Local.

    • V rozbaľovacom zozname Zdrojový projekt vyberte náš predtým potvrdený projekt a vyberte značku verzie, ktorú ste projektu priradili. Dajte vydaniu Názov a cestu (čo môže byť ľubovoľný náhodný reťazec) a stlačte Vytvoriť.

    7. Nasaďte náš model ako webovú službu

    • Vyberte model zo zoznamu aktív spojených s našim projektom. Na paneli podrobností modelu stlačte tlačidlo webovej služby.

    • Na obrazovke nasadenia modelu zadajte jedinečný názov, rezervujte si niektoré procesory a pamäť a potom stlačte tlačidlo Vytvoriť.

    8. Nasaďte naše skripty ako prácu

    • Na obrazovke nasadenia skriptu uveďte názov úlohy, nastavte typ na Spustenie skriptu, pridajte v1 ako argument príkazového riadku a potom stlačte Vytvoriť.

    Opakujte tieto kroky pre zvyšné 2 skripty.

    9. Zabezpečte nasadenie online

    Ak na stránke projektu vyberiete kartu Nasadenia, všimnete si, že všetky nasadenia sú uvedené ako zakázané.

    Ak chcete spustiť nasadenie online, stlačte ikonu tlačidla Spustiť, ktorá je ikonou úplne zľava uvedenou v hornej časti stránky. Po dokončení akcie by sa malo zobraziť nasledujúce.

    Poznámka: Možno budete musieť manuálne povoliť nasadenie modelu pomocou možností ponuky uvedených na pravej strane riadku modelu v tabuľke nasadenia.

    10. Zhromažďujte údaje koncových bodov API na použitie v skriptoch

    Niektoré z našich skriptov budú potrebovať prístup k nášmu nasadenému modelu a v niektorých prípadoch k ďalším nasadeným skriptom.

    Tu je rýchly prehľad toho, čo naše skripty robia a vyžadujú:

    feature_engineering.py - tento skript plní rovnakú funkciu ako náš notebook s funkciami pca. Načíta údaje z množiny údajov o víne a potom na ich transformáciu použije techniky strojového učenia. Výstupom budú dva dátové súbory - funkcie a cieľ. Upozorňujeme, že k týmto dátovým súborom bude pripojená značka verzie, aby ich obsah nebol prepísaný pri každom spustení tohto skriptu. Tento skript nevyžaduje prístup k nášmu modelu ani k iným skriptom.

    model_scoring.py - tento skript je dávkový procesor. Číta dátový súbor s funkciami a jednotlivé funkcie boduje ich spustením v našom modeli. Výstupom bude dátový súbor scoring_output. Upozorňujeme, že v dátovom súbore bude pripojená značka verzie, aby sa jeho obsah neprepísal pri každom spustení tohto skriptu. Tento skript vyžaduje prístup k nášmu nasadenému modelu.

    extract_and_score.py - tento skript bol vytvorený pre väčšie pohodlie a je možné ho použiť namiesto samostatného spustenia predchádzajúcich skriptov. Najprv vyvolá skript feature_engineering, potom po dokončení vyvolá skript model_scoring. Tento skript vyžaduje prístup k ďalším nasadeným skriptom.

    Pre prístup k nasadenému modelu alebo skriptom musíme zhromaždiť súvisiace koncové body API a autorizačný token. Všetky tieto hodnoty sú k dispozícii na stránkach nasadenia pre každý z objektov. Koncové body budú mať nasledujúci formát:

    • koncové body modelu budú končiť / skóre.
    • koncové body skriptu budú zakončené buď / trigger, / status alebo / cancel (čo zodpovedá akciám: start, status a stop).

    Ak chcete získať koncový bod pre náš nasadený model, kliknite na model na karte Aktíva na stránke projektu.

    Koncový bod je uvedený v hornej časti stránky. Endpoint aj Deployment Token je možné uložiť do schránky kliknutím na ich príslušné ikony.

    Opakujte tento krok a načítajte koncové body pre skripty feature_engineering aj model_scoring.

    Poznámka: Budete potrebovať iba jednu kópiu tokenu nasadenia. Bude to rovnaké pre všetky nasadenia v rámci tohto projektu.

    11. Upravte skripty v aplikácii Watson Studio Local

    Po zhromaždení koncových bodov nasadenia a tokenu nasadenia sa musíme vrátiť do miestneho režimu Watson Studio, aby sme mohli upravovať a testovať naše skripty.

    Prejdite do zoznamu Majetok pre projekt a vyberte položku Skripty. Kliknutím na súbor skriptu ho otvoríte v režime úprav.

    Skripty, ktoré upravíme, sú tie, ktoré odkazujú na objekty nasadenia. Sú to:

    • U skriptu model_scoring nahraďte hodnotami tokenu a koncového bodu a potom uložte novú verziu skriptu.

    U skriptu extract_and_score nahraďte hodnoty tokenu a koncového bodu. Hodnoty koncového bodu sú pre skripty nasadenia feature_engineering a model_scoring.

    Dôležité: Koncové body budú končiť reťazcom / spúšťačom. Vymažte túto časť adresy URL, pretože skript podľa potreby pripojí ku koncovým bodom buď / trigger alebo / status.

    Dokončite uložením novej verzie skriptu kliknutím na ikonu Uložiť umiestnenú v pravej hornej časti stránky.

    12. Spustite lokálne skripty na testovanie

    Aby ste nemuseli prechádzať medzi programami Watson Studio Local a Watson Machine Learning (čo zahŕňa opätovné nasadenie a vytváranie nových vydaných verzií), uistite sa, že skripty sa najskôr spúšťajú lokálne v programe Watson Studio Local.

    Skripty je možné spustiť buď z panela podrobností skriptu, alebo z editora skriptov.

    Spustiť ako úloha na paneli podrobností skriptu:

    Začnite skriptom feature_engineering. Pomocou panela s ponukami na pravej strane riadka skriptu vytvorte úlohu a spustite skript.

    Na paneli Vytvoriť spustenie úlohy zadajte jedinečný názov a nezabudnite použiť nasledujúce možnosti:

    • Typ: Spustenie skriptu
    • Pracovník: Python 3
    • Zdrojové dielo: /scripts/feature_engineering.py
    • Argumenty príkazového riadku: v1
    • Plánované spustenie: Na požiadanie

    Po stlačení tlačidla Vytvoriť sa zobrazí panel spustenia.

    Ak sa posuniete trochu nadol, uvidíte tlačidlo Spustiť teraz. Kliknutím na ňu spustíte skript. Opäť sa vám zobrazí dialógové okno, ktoré vyžaduje, aby ste mu dali názov spustenia. Zvyšok hodnôt bude predvolene nastavený na hodnoty, ktoré ste už nastavili, takže ich nie je potrebné upravovať. Kliknutím na tlačidlo Spustiť spustíte skript.

    Budete prenesení späť na panel spustenia, kde uvidíte stav (uvedený v časti Trvanie) a chvost protokolu. Po úspešnom dokončení by sa vám v zozname Sady údajov v zozname Súbory mali zobraziť 2 nové súbory.

    POZNÁMKA: Vytvorené dátové súbory (cieľ a funkcie) budú mať k názvu pripojenú značku verzie. Toto sa zhoduje s argumentom príkazového riadku, ktorý sme odovzdali do skriptu.

    Spustite interaktívne z editora skriptov

    • na stránke projektu kliknite na Skripty v zozname Aktíva a potom kliknite na skript feature_engineering v zozname. Zobrazí sa editor skriptov.

    Kliknite na tlačidlo Spustiť konfiguráciu na paneli nástrojov a potom pridajte v1 ako argument príkazového riadku.

    Potiahnutím ikony veľkosti na pravej strane panela otvoríte denník konzoly. Potom spustite skript kliknutím na tlačidlo Spustiť - & gt Spustiť ako úlohu na paneli nástrojov.

    Skript začne vykonávať a zobrazovať výstup do protokolu konzoly.

    Pri použití ktorejkoľvek z týchto metód opakujte tento proces, aby ste spustili skript model_scoring a potom skript extract_and_score.

    POZNÁMKA: Skript extract_and_score zlyhá, keď sa pokúsi skontrolovať stav skriptu model_scoring. Pamätajte, že vyvoláva ďalšie skripty volaním ich koncových bodov nasadených vo Watson Machine Learning. Problém je v tom, že tieto nasadené skripty ešte nemajú aktualizované informácie o koncovom bode a nebudú k dispozícii, kým svoje zmeny nepresunieme späť do modelu verzie Watson Machine Learning (čo urobíme ďalej).

    Po overení skriptov vykonajte zmeny a odovzdajte ich do hlavného úložiska Watson Studio, ako je to popísané vyššie v kroku č. 5. Uistite sa, že ste narazili na číslo verzie.

    13. Spravujte svoj model pomocou IBM Watson Machine Learning

    Spustite program IBM Watson Machine Learning výberom z hlavnej rozbaľovacej ponuky na domovskej stránke programu Watson Studio Local.

    Najskôr musíme aktualizovať náš projekt vydania, aby sme získali všetky najnovšie verzie našich skriptov.

    Na domovskej stránke Watson Machine Learning kliknite na našu dlaždicu projektu.

    V rade ikon uvedených na banneri stránky kliknite na ikonu Aktualizovať.

    Na obrazovke s aktualizáciou vyberte z rozbaľovacej ponuky Zdrojový projekt náš projekt Watson Studio Local. Potom vyberte značku verzie spojenú s našim najnovším potvrdením.

    Teraz, keď sú aktualizované všetky naše aktíva, môžeme skutočne spravovať náš model sledovaním jeho používania a výkonu.

    Aby sme sa dostali do pohybu, začnime spustením nášho skriptu extract_and_score. Ako už bolo vysvetlené, toto sa načíta v aktuálnom súbore CSV s vínom, transformuje sa a potom sa každé víno porovná s našim modelom.

    • Na stránke Dielo vyberte skript extract_and_score. Na stránke s podrobnosťami kliknite na názov skriptu, aby sa zobrazila stránka na spustenie skriptu. Potom kliknite na kartu API.

    Upozorňujeme, že hodnota argumentov príkazového riadku je nastavená na v1. Môžete ich nastaviť na ľubovoľné miesto, ale pripojí sa k názvom súborov vygenerovaných týmto skriptom. Takto sa vyhnete preplneniu údajov z predchádzajúcich cyklov tohto skriptu.

    Ak chcete spustiť skript, kliknite na kartu Prehľad a na stránke sa posuňte nadol do sekcie Spustenia. Potom kliknite na tlačidlo Spustiť teraz.

    V úvodnom dialógovom okne zadajte názov, v prípade potreby upravte argument príkazového riadku a potom kliknite na tlačidlo Spustiť.

    Na rovnakom paneli môžete zobraziť stav úlohy. Ak chcete zobraziť súvisiaci súbor denníka, kliknite na možnosť ponuky Zobraziť denníky umiestnenú na pravej strane riadku úlohy.

    Na hlavnom paneli môžete tiež vidieť, že skript bol úspešne dokončený. Upozorňujeme tiež, že v prípade skriptu na extrakciu a skórovanie boli spustené tri samostatné úlohy (hlavný skript a dva vyvolané skripty).

    Ak sa skript úspešne dokončí, v projekte by mali byť tri dátové súbory s verziou, ktoré by sa mali pridať ako aktíva množín dát. Súbor scoring_output-v1 obsahuje konečné skóre klasifikácie vín.

    Tu sú odkazy na každý zo notebookov s príkladom výstupu:

    • Vzory kódov analýzy údajov: Páčil sa vám tento vzor kódu? Vyskúšajte naše ďalšie vzory kódov analýzy údajov
    • Zoznamy vzorov umelej inteligencie a dátových kódov: Pridajte si náš zoznam videí do záložiek so všetkými našimi videami s kódovým vzorom
    • Štúdio Watson: Osvojte si umenie dátovej vedy s Watson Studio od IBM
    • Iskra na IBM Cloud: Potrebujete klaster Spark? Vytvorte až 30 vykonávateľov Spark v IBM Cloud pomocou našej služby Spark

    Na tento kódový vzorec sa poskytuje licencia na základe softvérovej licencie Apache, verzia 2. Na samostatné kódové objekty tretích strán vyvolané v rámci tohto vzorového kódu majú licenciu ich príslušní poskytovatelia na základe svojich samostatných licencií. Príspevky podliehajú osvedčeniu o pôvode vývojára, verzia 1.1 (DCO) a softvérovej licencii Apache, verzia 2.


    Keras ImageDataGenerator a rozšírenie dát

    Aktualizácia 2020-06-04: Tento blogový príspevok je teraz kompatibilný s TensorFlow 2+!

    Tento tutoriál začneme diskusiou o rozšírení údajov a dôvodoch, prečo ich používame.

    Potom sa budem venovať trom typom rozšírenia dát, ktoré uvidíte pri tréningu hlbokých neurónových sietí:

    1. Generovanie množiny údajov a rozširovanie údajov prostredníctvom rozšírenia údajov (menej časté)
    2. Rozšírenie údajov na mieste / za pochodu (najbežnejšie)
    3. Kombinácia generovania množiny údajov a rozšírenia na mieste

    Odtiaľ vás naučím, ako aplikovať rozšírenie dát na svoje vlastné množiny údajov (pomocou všetkých troch metód) pomocou triedy Keras ‘ImageDataGenerator.

    Čo je to rozšírenie dát?

    Rozšírenie dát zahŕňa širokú škálu techník používaných na generovanie „nových“ tréningových vzoriek z tých pôvodných aplikáciou náhodných chvení a porúch (ale súčasne zaisťujúcich, aby sa nezmenili štítky údajov).

    Naším cieľom pri aplikácii rozšírenia údajov je zvýšiť zovšeobecniteľnosť modelu.

    Vzhľadom na to, že naša sieť neustále vidí nové, mierne upravené verzie vstupných údajov, je schopná učiť sa robustnejšie funkcie.

    V čase testovania neaplikujeme rozšírenie dát a jednoducho vyhodnotíme našu trénovanú sieť na neupravených testovacích dátach & # 8212, vo väčšine prípadov uvidíte zvýšenie presnosti testovania, možno na úkor mierneho poklesu presnosti tréningu.

    Jednoduchý príklad rozšírenia údajov

    Obrázok 2: Vľavo: Vzorka 250 údajových bodov, ktoré presne sledujú normálne rozdelenie. Správny: Pridanie malého množstva náhodného „chvenia“ do distribúcie. Tento typ rozšírenia údajov zvyšuje zovšeobecniteľnosť našich sietí.

    Uvažujme Obrázok 2 (vľavo) normálneho rozdelenia s nulovým stredným a jednotkovým rozptylom.

    Výcvik modelu strojového učenia na týchto dátach môže viesť k tomu, že budeme modelovať distribúciu presne & # 8212, avšak v aplikáciách z reálneho sveta nasledujú dáta zriedka po takej peknej a úhľadnej distribúcii.

    Namiesto toho, aby sme zvýšili zovšeobecniteľnosť nášho klasifikátora, môžeme najskôr náhodne chvieť body pozdĺž distribúcie pridaním niektorých náhodných hodnôt čerpané z náhodného rozdelenia (správny).

    Náš dej stále nasleduje po približne normálne rozdelenie, ale nejde o dokonalý distribúcia ako vľavo.

    Model trénovaný na týchto upravených, rozšírených dátach sa skôr zovšeobecní na príklad dátových bodov, ktoré nie sú obsiahnuté v tréningovej sade.

    Počítačové videnie a rozšírenie dát

    Obrázok 3: V počítačovom videní zväčšenie dát vykonáva náhodné manipulácie so snímkami. Spravidla sa uplatňuje v troch scenároch, o ktorých sa pojednáva v tomto blogovom príspevku.

    V súvislosti s počítačovým videním sa rozširovanie údajov požičiava prirodzene.

    Napríklad môžeme získať rozšírené údaje z pôvodných obrázkov použitím jednoduchých geometrických transformácií, napríklad náhodných:

    1. Preklady
    2. Rotácie
    3. Zmeny rozsahu
    4. Strihanie
    5. Horizontálne (a v niektorých prípadoch zvislé) prevrátenie

    Aplikácia (malého) množstva transformácií na vstupný obrázok mierne zmení jeho vzhľad, ale to nie zmeniť štítok triedy & # 8212, čím sa rozšírenie dát stane veľmi prirodzenou a ľahkou metódou uplatniteľnou na úlohy počítačového videnia.

    Tri typy rozšírenia údajov

    Existujú tri typy rozšírenia údajov, s ktorými sa pravdepodobne stretnete pri aplikácii hlbokého učenia v kontexte aplikácií počítačového videnia.

    Presná definícia rozšírenia údajov je „správna“ úplne závislé v kontexte vášho projektu / súboru experimentov.

    Nájdite si čas a prečítajte si túto časť carefully as I see many deep learning practitioners confuse what data augmentation does and does not do.

    Type #1: Dataset generation and expanding an existing dataset (less common)

    Obrázok 4: Type #1 of data augmentation consists of dataset generation/dataset expansion. This is a less common form of data augmentation.

    The first type of data augmentation is what I call dataset generation alebo dataset expansion.

    As you know machine learning models, and especially neural networks, can require quite a bit of training data — but what if you don’t have very much training data in the first place?

    Let’s examine the most trivial case where you only have one image and you want to apply data augmentation to create an entire dataset of images, all based on that one image.

    To accomplish this task, you would:

    1. Load the original input image from disk.
    2. Randomly transform the original image via a series of random translations, rotations, etc.
    3. Take the transformed image and write it back out to disk.
    4. Repeat steps 2 and 3 a total of N times.

    After performing this process you would have a directory full of randomly transformed “new” images that you could use for training, all based on that single input image.

    This is, of course, an incredibly simplified example.

    You more than likely have more than a single image — you probably have 10s or 100s of images and now your goal is to turn that smaller set into 1000s of images for training.

    In those situations, dataset expansion and dataset generation may be worth exploring.

    But there’s a problem with this approach — we haven’t exactly increased the ability of our model to generalize.

    Yes, we have increased our training data by generating additional examples, but all of these examples are based on a super small dataset.

    Keep in mind that our neural network is only as good as the data it was trained on.

    We cannot expect to train a NN on a small amount of data and then expect it to generalize to data it was nikdy trained on and has never seen before.

    If you find yourself seriously considering dataset generation and dataset expansion, you should take a step back and instead invest your time gathering additional data or looking into methods of behavioral cloning (and then applying the type of data augmentation covered in the “Combining dataset generation and in-place augmentation” section below).

    Type #2: In-place/on-the-fly data augmentation (most common)

    Figure 5: Type #2 of data augmentation consists of on-the-fly image batch manipulations. This is the most common form of data augmentation with Keras.

    The second type of data augmentation is called in-place data augmentation alebo on-the-fly data augmentation. This type of data augmentation is what Keras’ ImageDataGenerator class implements.

    Using this type of data augmentation we want to ensure that our network, when trained, sees new variations of our data at each and every epoch.

    Figure 5 demonstrates the process of applying in-place data augmentation:

    1. Step #1: An input batch of images is presented to the ImageDataGenerator .
    2. Step #2: The ImageDataGenerator transforms each image in the batch by a series of random translations, rotations, etc.
    3. Step #3: The randomly transformed batch is then returned to the calling function.

    There are two important points that I want to draw your attention to:

    1. The ImageDataGenerator is nie returning both the original data and the transformed data — the class only returns the randomly transformed data.
    2. We call this “in-place” and “on-the-fly” data augmentation because this augmentation is done at training time (i.e., we are not generating these examples ahead of time/prior to training).

    When our model is being trained, we can think of our ImageDataGenerator class as “intercepting” the original data, randomly transforming it, and then returning it to the neural network for training, all the while the NN has no idea the data was modified!

    I’ve written previous tutorials on the PyImageSearch blog where readers think that Keras’ ImageDateGenerator class is an “additive operation”, similar to the following (incorrect) figure:

    Figure 6: How Keras data augmentation does nie work.

    In the above illustration the ImageDataGenerator accepts an input batch of images, randomly transforms the batch, and then returns both the original batch and modified data — again, this is nie what the Keras ImageDataGenerator does. Instead, the ImageDataGenerator class will return just the randomly transformed data.

    When I explain this concept to readers the next question is often:

    But Adrian, what about the original training data? Why is it not used? Isn’t the original training data still useful for training?

    Keep in mind that the entire point of the data augmentation technique described in this section is to ensure that the network sees “new” images that it has never “seen” before at each and every epoch.

    If we included the original training data along with the augmented data in each batch, then the network would “see” the original training data multiple times, effectively defeating the purpose. Secondly, recall that the overall goal of data augmentation is to increase the generalizability of the model.

    To accomplish this goal we “replace” the training data with randomly transformed, augmented data.

    In practice, this leads to a model that performs better on our validation/testing data but perhaps performs slightly worse on our training data (to due to the variations in data caused by the random transforms).

    You’ll learn how to use the Keras ImageDataGenerator class later in this tutorial.

    Type #3: Combining dataset generation and in-place augmentation

    The final type of data augmentation seeks to combine both dataset generation and in-place augmentation — you may see this type of data augmentation when performing behavioral cloning.

    A great example of behavioral cloning can be seen in self-driving car applications.

    Creating self-driving car datasets can be extremely time consuming and expensive — a way around the issue is to instead use video games and car driving simulators.

    Video game graphics have become so life-like that it’s now possible to use them as training data.

    Therefore, instead of driving an actual vehicle, you can instead:

    • Play a video game
    • Write a program to play a video game
    • Use the underlying rendering engine of the video game

    …all to generate actual data that can be used for training.

    Once you have your training data you can go back and apply Type #2 data augmentation (i.e., in-place/on-the-fly data augmentation) to the data you gathered via your simulation.

    Configuring your development environment

    To configure your system for this tutorial, I first recommend following either of these tutorials:

    Either tutorial will help you configure you system with all the necessary software for this blog post in a convenient Python virtual environment.

    Project structure

    Before we dive into the code let’s first review our directory structure for the project:

    First, there are two dataset directories which are not to be confused:

    • dogs_vs_cats_small/ : A subset of the popular Kaggle Dogs vs. Cats competition dataset. In my curated subset, only 2,000 images (1,000 per class) are present (as opposed to the 25,000 images for the challenge).
    • generated_dataset/ : We’ll create this generated dataset using the cat.jpg and dog.jpg images which are in the parent directory. We’ll utilize data augmentation Type #1 to generate this dataset automatically and fill this directory with images.

    Next, we have our pyimagesearch module which contains our implementation of the ResNet CNN classifier.

    Today, we’ll review two Python scripts:

    • train.py : Used to train models for both Type #1 a Type #2 (and optionally Type #3 if the user so wishes) data augmentation techniques. We’ll perform three training experiments resulting in each of the three plot*.png files in the project folder.
    • generate_images.py : Used to generate a dataset from a single image using Type #1.

    Implementing our training script

    In the remainder of this tutorial we’ll be performing three experiments:

    1. Experiment #1: Generate a dataset via dataset expansion and train a CNN on it.
    2. Experiment #2: Use a subset of the Kaggle Dogs vs. Cats dataset and train a CNN without data augmentation.
    3. Experiment #3: Repeat the second experiment, but this time with data augmentation.

    All of these experiments will be accomplished using the same Python script.

    Open up the train.py script and let’s get started:

    On Lines 2-18 our necessary packages are imported. Line 10 is our ImageDataGenerator import from the Keras library — a class for data augmentation.

    Our script accepts three command line arguments via the terminal:

    • --dataset : The path to the input dataset.
    • --augment : Whether “on-the-fly” data augmentation should be used (refer to type #2 above). By default, this method is nie performed.
    • --plot : The path to the output training history plot.

    Let’s proceed to initialize hyperparameters and load our image data:

    Training hyperparameters, including initial learning rate, batch size, and number of epochs to train for, are initialized on Lines 32-34.

    From there Lines 39-53 grab imagePaths , load images, and populate our data and labels lists. The only image preprocessing we perform at this point is to resize each image to 64吼px.

    Next, let’s finish preprocessing, encode our labels, and partition our data:

    On Line 57, we convert data to a NumPy array as well as scale all pixel intensities to the range [0, 1]. This completes our preprocessing.

    From there we perform “one-hot encoding” of our labels (Lines 61-63). This method of encoding our labels results in an array that may look like this:

    For this sample of data, there are two cats ( [1., 0.] ) and five dogs ( [0., 1] ) where the label corresponding to the image is marked as “hot”.

    From there we partition our data into training and testing splits marking 75% of our data for training and the remaining 25% for testing (Lines 67 and 68).

    Now, we are ready to initialize our data augmentation object:

    Line 71 initializes our empty data augmentation object (i.e., no augmentation will be performed). This is the default operation of this script.

    Let’s check if we’re going to override the default with the --augment command line argument:

    Line 75 checks to see if we are performing data augmentation. If so, we re-initialize the data augmentation object with random transformation parameters (Lines 77-84). As the parameters indicate, random rotations, zooms, shifts, shears, and flips will be performed during in-place/on-the-fly data augmentation.

    Let’s compile and train our model:

    2020-06-04 Update: Formerly, TensorFlow/Keras required use of a method called .fit_generator in order to accomplish data augmentation. Now, the .fit method can handle data augmentation as well, making for more-consistent code. This also applies to the migration from .predict_generator to .predict . Be sure to check out my other article fit and fit_generator after you’re done reading this tutorial.

    Lines 88-92 construct our ResNet model using Stochastic Gradient Descent optimization and learning rate decay. We use "binary_crossentropy" loss for this 2-class problem. If you have more than two classes, be sure to use "categorial_crossentropy" .

    Lines 96-100 then train our model. The aug object handles data augmentation in batches (although be sure to recall that the aug object will only perform data augmentation if the --augment command line argument was set).

    Finally, we’ll evaluate our model, print statistics, and generate a training history plot:

    2020-06-04 Update: In order for this plotting snippet to be TensorFlow 2+ compatible the H.history dictionary keys are updated to fully spell out “accuracy” sans “acc” (i.e., H.history["val_accuracy"] and H.history["accuracy"] ). It is semi-confusing that “val” is not spelled out as “validation” we have to learn to love and live with the API and always remember that it is a work in progress that many developers around the world contribute to.

    Line 104 makes predictions on the test set for evaluation purposes. A classification report is printed via Lines 105 and 106.

    From there, Lines 109-120 generate and save an accuracy/loss training plot.

    Generating a dataset/dataset expansion with data augmentation and Keras

    In our first experiment, we will perform dataset expansion via data augmentation with Keras.

    Our dataset will contain 2 classes and initially, the dataset will trivially contain only 1 image per class:

    We’ll utilize Type #1 data augmentation (see the “Type #1: Dataset generation and expanding an existing dataset” section above) to generate a new dataset with 100 images per class:

    Again, this meant to be an example — in a real-world application you would have 100s of example images, but we’re keeping it simple here so you can learn the concept.

    Generating the example dataset

    Before we can train our CNN we first need to generate an example dataset.

    From our “Project Structure” section above you know that we have two example images in our root directory: cat.jpg and dog.jpg . We will use these example images to generate 100 new training images per class (200 images in total).

    To see how we can use data augmentation to generate new examples, open up the generate_images.py file and follow along:

    Lines 2-6 import our necessary packages. Our ImageDataGenerator is imported on Line 2 and will handle our data augmentation with Keras.

    From there, we’ll parse three command line arguments:

    • --image : The path to the input image. We’ll generate additional random, mutated versions of this image.
    • --output : The path to the output directory to store the data augmentation examples.
    • --total : The number of sample images to generate.

    Let’s go ahead and load our image and initialize our data augmentation object:

    Our image is loaded and prepared for data augmentation via Lines 21-23. Image loading and processing is handled via Keras functionality (i.e. we aren’t using OpenCV).

    From there, we initialize the ImageDataGenerator object. This object will facilitate performing random rotations, zooms, shifts, shears, and flips on our input image.

    Next, we’ll construct a Python generator and put it to work until all of our images have been produced:

    We will use the imageGen to randomly transform the input image (Lines 39 and 40). This generator saves images as .jpg files to the specified output directory contained within args["output"] .

    Finally, we’ll loop over examples from our image data generator and count them until we’ve reached the required total number of images.

    To run the generate_examples.py script make sure you have used the “Downloads” section of the tutorial to download the source code and example images.

    From there open up a terminal and execute the following command:

    Check the output of the generated_dataset/cats directory you will now see 100 images:

    Let’s do the same now for the “dogs” class:

    And now check for the dog images:

    A visualization of the dataset generation via data augmentation can be seen in Figure 6 at the top of this section — notice how we have accepted a single input image (of me — not of a dog or cat) and then created 100 new training examples (48 of which are visualized) from that single image.

    Experiment #1: Dataset generation results

    We are now ready to perform our first experiment:

    Figure 8: Data augmentation with Keras Experiment #1 training accuracy/loss results.

    Our results show that we were able to obtain 100% accuracy with little effort.

    Of course, this is a trivial, contrived example. In practice, you would not be taking only a single image and then building a dataset of 100s or 1000s of images via data augmentation. Instead, you would have a dataset of 100s of images and then you would apply dataset generation to that dataset — but again, the point of this section was to demonstrate on a simple example so you could understand the process.

    Training a network with in-place data augmentation

    The more popular form of (image-based) data augmentation is called in-place data augmentation (see the “Type #2: In-place/on-the-fly data augmentation” section of this post for more details).

    When performing in-place augmentation our Keras ImageDataGenerator will:

    1. Accept a batch of input images.
    2. Randomly transform the input batch.
    3. Return the transformed batch to the network for training.

    We’ll explore how data augmentation can reduce overfitting and increase the ability of our model to generalize via two experiments.

    To accomplish this task we’ll be using a subset of the Kaggle Dogs vs. Cats dataset:

    We’ll then train a variation of ResNet, from scratch, on this dataset with and without data augmentation.

    Experiment #2: Obtaining a baseline (no data augmentation)

    In our first experiment we’ll perform no data augmentation:

    Looking at the raw classification report you’ll see that we’re obtaining 64% accuracybut there’s a problem!

    Take a look at the plot associated with our training:

    Figure 9: For Experiment #2 we did not perform data augmentation. The result is a plot with strong indications of overfitting.

    There is dramatic overfitting occurring — at approximately epoch 15 we see our validation loss start to rise while training loss continues to fall. By epoch 20 the rise in validation loss is especially pronounced.

    This type of behavior is indicative of overfitting.

    The solution is to (1) reduce model capacity, and/or (2) perform regularization.

    Experiment #3: Improving our results (with data augmentation)

    Let’s now investigate how data augmentation can act as a form of regularization:

    We’re now up to 69% accuracy, an increase from our previous 64% accuracy.

    But more importantly, we are no longer overfitting:

    Figure 10: For Experiment #3, we performed data augmentation with Keras on batches of images in-place. Our training plot shows no signs of overfitting with this form of regularization.

    Note how validation and training loss are falling together with little divergence. Similarly, classification accuracy for both the training and validation splits are growing together as well.

    By using data augmentation we were able to combat overfitting!

    In nearly all situations, unless you have very good reason not to, you should be performing data augmentation when training your own neural networks.

    Čo bude ďalej? Odporúčam univerzitu PyImageSearch.

    Pevne verím, že keby ste mali správneho učiteľa, mohli by ste pán počítačové videnie a hlboké učenie.

    Myslíte si, že učenie sa počítačového videnia a hlbokého učenia musí byť časovo náročné, ohromujúce a komplikované? Alebo musí obsahovať zložitú matematiku a rovnice? Alebo vyžaduje diplom z počítačovej vedy?

    Všetko, čo potrebujete na zvládnutie počítačového videnia a hlbokého učenia, je, aby vám niekto vysvetlil veci jednoduché, intuitívne podmienky. A to je presne to, čo robím. Mojou misiou je zmeniť vzdelávanie a spôsob vyučovania zložitých tém umelej inteligencie.

    Ak to s učením počítačového videnia myslíte vážne, vašou ďalšou zastávkou by mala byť Univerzita PyImageSearch, najkomplexnejší počítačový videnie, hlboké vzdelávanie a online kurz OpenCV, ktorý je dnes k dispozícii. Tu sa dozviete, ako na to úspešne a sebavedomo aplikujte počítačové videnie na svoju prácu, výskum a projekty. Pripojte sa ku mne v ovládaní počítačového videnia.

    Vo vnútri univerzity PyImageSearch nájdete:

    • & skontrolovať 23 kurzov na základné počítačové videnie, hlboké učenie a témy OpenCV
    • & Skontrolujte 23 osvedčení o dokončení
    • & skontrolovať 35h 14m video na požiadanie
    • & skontrolovať Boli vydané úplne nové kurzy každý mesiac, ktorý vám umožní držať krok s najmodernejšími technikami
    • & skontrolovať Predkonfigurované notebooky Jupyter v aplikácii Google Colab
    • & začiarknite políčko Spustiť všetky príklady kódu vo webovom prehliadači - funguje v systémoch Windows, macOS a Linux (nevyžaduje sa žiadna konfigurácia vývojového prostredia!)
    • & skontrolovať Prístup k centralizované kódové úložiská pre všetko 400+ návodov na PyImageSearch
    • & skontrolovať Jednoduché sťahovanie jedným kliknutím pre kód, súbory údajov, vopred vyškolené modely atď.
    • & check Access on mobile, laptop, desktop, etc.

    How to Use a Learned Embedding for Categorical Data

    A learned embedding, or simply an “embedding,” is a distributed representation for categorical data.

    Each category is mapped to a distinct vector, and the properties of the vector are adapted or learned while training a neural network. The vector space provides a projection of the categories, allowing those categories that are close or related to cluster together naturally.

    This provides both the benefits of an ordinal relationship by allowing any such relationships to be learned from data, and a one hot encoding in providing a vector representation for each category. Unlike one hot encoding, the input vectors are not sparse (do not have lots of zeros). The downside is that it requires learning as part of the model and the creation of many more input variables (columns).

    The technique was originally developed to provide a distributed representation for words, e.g. allowing similar words to have similar vector representations. As such, the technique is often referred to as a word embedding, and in the case of text data, algorithms have been developed to learn a representation independent of a neural network. For more on this topic, see the post:

    An additional benefit of using an embedding is that the learned vectors that each category is mapped to can be fit in a model that has modest skill, but the vectors can be extracted and used generally as input for the category on a range of different models and applications. That is, they can be learned and reused.

    Embeddings can be used in Keras via the Embedding layer.

    For an example of learning word embeddings for text data in Keras, see the post:

    One embedding layer is required for each categorical variable, and the embedding expects the categories to be ordinal encoded, although no relationship between the categories is assumed.

    Each embedding also requires the number of dimensions to use for the distributed representation (vector space). It is common in natural language applications to use 50, 100, or 300 dimensions. For our small example, we will fix the number of dimensions at 10, but this is arbitrary you should experimenter with other values.

    First, we can prepare the input data using an ordinal encoding.

    The model we will develop will have one separate embedding for each input variable. Therefore, the model will take nine different input datasets. As such, we will split the input variables and ordinal encode (integer encoding) each separately using the LabelEncoder and return a list of separate prepared train and test input datasets.

    The prepare_inputs() function below implements this, enumerating over each input variable, integer encoding each correctly using best practices, and returning lists of encoded train and test variables (or one-variable datasets) that can be used as input for our model later.

    Now we can construct the model.

    We must construct the model differently in this case because we will have nine input layers, with nine embeddings the outputs of which (the nine different 10-element vectors) need to be concatenated into one long vector before being passed as input to the dense layers.

    We can achieve this using the functional Keras API. If you are new to the Keras functional API, see the post:

    First, we can enumerate each variable and construct an input layer and connect it to an embedding layer, and store both layers in lists. We need a reference to all of the input layers when defining the model, and we need a reference to each embedding layer to concentrate them with a merge layer.

    We can then merge all of the embedding layers, define the hidden layer and output layer, then define the model.

    When using a model with multiple inputs, we will need to specify a list that has one dataset for each input, e.g. a list of nine arrays each with one column in the case of our dataset. Thankfully, this is the format we returned from our prepare_inputs() function.

    Therefore, fitting and evaluating the model looks like it does in the previous section.

    Additionally, we will plot the model by calling the plot_model() function and save it to file. This requires that pygraphviz and pydot are installed, which can be a pain on some systems. If you have trouble, just comment out the import statement and call to plot_model().

    Tying this all together, the complete example of using a separate embedding for each categorical input variable in a multi-input layer model is listed below.

    Running the example prepares the data as described above, fits the model, and reports the performance.

    Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

    In this case, the model performs reasonably well, matching what we saw for the one hot encoding in the previous section.

    As the learned vectors were trained in a skilled model, it is possible to save them and use them as a general representation for these variables in other models that operate on the same data. A useful and compelling reason to explore this encoding.

    To confirm our understanding of the model, a plot is created and saved to the file embeddings.png in the current working directory.

    The plot shows the nine inputs each mapped to a 10 element vector, meaning that the actual input to the model is a 90 element vector.

    Note: Click to the image to see the large version.

    Plot of the Model Architecture With Separate Inputs and Embeddings for each Categorical Variable
    Click to Enlarge.


    X_train, y_train = train_generator.next() X_test, y_test = validation_generator.next()

    X_train, y_train = next(train_generator) X_test, y_test = next(validation_generator)

    As per the above answer, the below code just gives 1 batch of data.

    To extract full data from the train_generator use below code -

    y_train, y_test values will be based on the category folders you have in train_data_dir. Not values will be like 0,1,2,3. mapping to class names in Alphabetical Order.

    Otherwise, use below code to get indices map

    Make sure they both are the same.

    More of an indirect answer, but maybe helpful to some: Here is a script I use to sort test and train images into the respective (sub) folders to work with Keras and the data generator function (MS Windows).


    Summary

    In this tutorial, you learned how to use the Keras deep learning library for regression.

    Specifically, we used Keras and regression to predict the price of houses based on four numerical and categorical attributes:

    • Number of bedrooms
    • Number of bathrooms
    • Area (i.e., square footage)
    • Zip code

    Overall our neural network obtained a mean absolute percentage error of 22.71%, implying that, on average, our house price predictions will be off by 22.71%.

    That raises the questions:

    • How can we better our house price prediction accuracy?
    • What if we leveraged images for each house? Would that improve accuracy?
    • Is there some way to combine both our categorical/numerical attributes with our image data?

    To answer these questions you’ll need to stay tuned for the remaining to tutorials in this Keras regression series.

    To download the source code to this post (and be notified when the next tutorial is published here on PyImageSearch), just enter your email address in the form below.

    Download the Source Code and FREE 17-page Resource Guide

    Enter your email address below to get a .zip of the code and a FREE 17-page Resource Guide on Computer Vision, OpenCV, and Deep Learning. Inside you'll find my hand-picked tutorials, books, courses, and libraries to help you master CV and DL!

    About the Author

    Hi there, I’m Adrian Rosebrock, PhD. All too often I see developers, students, and researchers wasting their time, studying the wrong things, and generally struggling to get started with Computer Vision, Deep Learning, and OpenCV. I created this website to show you what I believe is the best possible way to get your start.


    Making your model impactful

    Tada! We’ve now made our lead scoring model impactful by sending results directly into Intercom. To get a sense of how this might show up for a sales team member, here you can see each example lead now has a custom attribute listing whether or not they are likely to convert:

    With these labels easily available for each potential lead, a sales team member can start to prioritize their time and pick who they will reach out to first. This will hopefully lead to better efficiency, and more sales for your business! There are many ways to measure the success of these outcomes, but we’ll visit that at another time!