2019. december 30., hétfő

Python online + elarning linkek

Online python: használatot lehetővétevő oldalak












Python online oktatási oldalak, :








2019. december 20., péntek

Szófelhő / word cloud készítése python nyelven

Szó felhő készítése Python-ban (wordcloud modul használatával).


A szófelhő egy formába rendezett, szavakból álló illusztrációs megjelenítés, ahol a megjelenített forma
és a szavak jelentése, előfordulási gyakorisága  közötti információ függés megjelenítése történik.

Nagyon jól használható az emberi képfeldolgozás kihasználásával ad információt kapcsolatot hangsúlyt
az illusztrációként megjelenített kép.

Lényegében sugallja az információt mivel a kiaknázásban a képet néző személy be van vonva
és egy aha (ráismerés élménnyel) is mélyíti a fontos a szavakban rejlő információ felismerését, rögzülését.

Többféle online portál is nyújt ilyen szolgáltatást, de most a Python nyelvbe rejlő lehetőséget villantjuk meg.



Szükséges modulok:


import matplotlib.pyplot as plt
import numpy as np
from PIL import Image 
from wordcloud import WordCloud


Generálás:


wc = WordCloud(background_color="white", max_words=2000, mask=mask,
              max_font_size=50, contour_width=3, contour_color='red')
wc.generate(text)



Megjelenítés:


plt.figure(figsize=[8,8]) 
plt.imshow(wc, interpolation="bilinear")
plt.axis("off")
plt.margins(x=0, y=0)
plt.tight_layout(pad = 0)
plt.show()




Egy karácsonyi minta feldolgozás eredménye:







Egy Trónok harca angol film felírat szöveg feldolgozás minta eredménye:









Egy megvalósítás minta:

https://github.com/klajosw/python/blob/master/kl_py_word_cloud.ipynb

2019. november 24., vasárnap

AI MI típusok és python modulok

AI típusok és Python modulok




Megerősítéses tanulás 

A megerősítéses tanulás a gépi tanulás fontos családtagja. Tanulási stílusa olyan, mint egy kicsi csecsemő. Mivel különös a körülötte lév környezetre, a környezetet folyamatosan érintkezve tanulja meg a környezetbõl, így ismeri a környezetet. Nagyon sok módja van, hogy megerősítse a tanulás, mint a Q-tanulás, Sarsa és így tovább, ez alapú vizuális szimuláció, számítógép megtanulja, hogyan kell nézni és értelmezni ezt.

 Evolúciós algoritmus 

Az evolúciós algoritmus a gépi tanulás egyik ága. Az egyik leghíresebb evolúciós algoritmus a genetikai algoritmus. Az evolúciós algoritmust Darwin evolúciós elmélete ihlette. Fő vezérlő elvek és használatuk fejlődése a szerint hogy: "A legmegfelelőbb túlélés, a kellemetlenségek kiküszöbölése" törekvéssel. Az evolúciós algoritmus fő szakaszai: Klasszikus genetikai algoritmus , NeuroEvolution, Evolúciós stratégia


 Neurális hálózat: Tensorflow



A Tensorflow, a Google csapat által kifejlesztett neurális hálózati modul, születése miatt sok figyelmet kapott, és néhány év alatt sok frissítés történt. Ennek használatba vétele a Tensorflow infrastruktúrájával megismerkedéssel kezdődik. Az analógia miatt taníthatja az első ideghálózat felépítését. Nagyon jól modellezhető a Tensorflow használatával konvolúciós neurális hálózat CNN felépítésére a képek azonosítására. Ebben érdemes létrehozni az RNN ciklikus neurális hálózatot az állandóan változó helyzet előrejelzésére.


 Neurális hálózat: PyTorch

A PyTorch fejlesztési / felhasználási csapata, beleértve a Facebook-ot, az NVIDIA-t, a Twitter-t, és egyéb nagy márkák, és a Tensorflow egyik legnagyobb versenytársának tekinthető. A PyTorch egyszerű és könnyen használható,  azonban minden családnak megvannak a maga előnyei és hátrányai.



 Neurális hálózat: Theano

Theano hasonló a Tensorflow-hoz, sőt azt is mondhatjuk, hogy Theano a Tensorflow elnöke, azonban mivel tudományos környezetben született, a kutatók többsége használta. A Tensorflow-hoz képest ez is tökéletes. A neurális hálózati modul és az integrált Windows kompatibilitás, tehát a Theano is a legjobb választás a tanuláshoz.



 Neurális hálózat: Keras

A Keras egy fejlettebb neurális hálózati modul, amely a Tensorflow-ra és a Theano-ra épül, tehát kompatibilis a Windows, a Linux és a MacOS rendszerekkel, és a Keras használata neurális hálózatok létrehozásához könnyebb, mint a Tensorflow és a Theano, mert sokat optimalizált. Általában ha igény a grafikon gyors és egyszerűség, akkor a keras használata helyes. Minden ideghálózati forma kialakítható benne. Használata könnyebbséget jelent  azoknak a használata akik már rendelkeznek tapasztalatokkal a Theano vagy a Tensorflow alkalmazásban.



 Gépi tanulás Általános: SciKit-Learn

A SciKit-Learn, más néven sklearn, egyik kiváló komponens a sok gépi tanulási modul közül, mivel túl sok gépi tanulási módszert hoz össze, mint például a különféle felügyelt tanulás, felügyelet nélküli tanulás és félig felügyelt tanulás. Csakúgy, mint a svájcibicska a gépi tanulás modulok világában.
A sklearn alapvető használathoz,  kiválasztani a megfelelő gépi tanulási módszert, Általános edzési/tanítási módokat stb.


 Számítógépes látás

A számítógépes látás az utóbbi évek egyik fejlődésének fókuszpontja. Itt láthatja, hogy a számítógépek hogyan értik a képeket, hogyan nézhetik meg a dolgokat, és milyen érdekes alkalmazásokat kínálnak .




A neurális hálózatok tehát a neuronok különböző összekapcsolásaiból jönnek létre.

Általában egy irányított gráffal reprezentáljuk őket, amelyben a csomópontok az egyes neuronok, míg az irányok a kimenetektől a bemenetek felé mutatnak.

Bonyolultabb esetekben ez a jelölésmód már áttekinthetetlen lehet.  A neuron egy hálózaton belül általában csak meghatározott számú neuronnal vannak összekötve, és ez a kapcsolat általában egyirányú, ezért a hálózatokat különböző rétegekre szoktuk bontani az összekötések szerint.

Az egyes rétegekhez tartozó neuronok az előző réteg neuronjainak kimenetével, vagy a bemenettel, illetve a következő réteg bemenetével vannak összekötve.

    a. Bemeneti réteg: azok a neuronok találhatók itt, amelyek a bemeneti jel továbbítását végzik a hálózat felé. A legtöbb esetben nem jelöljük kettő külön. Ezek csak jeltovábbítást, a neuronok meghajtását végzik

    b. Rejtett réteg: a tulajdonképpeni feldolgozást végző neuronok tartoznak ide. Egy hálózaton belül több rejtett réteg is lehet. Jellemzője, hogy mind a bemeneteik, mind a kimenetük valamely más neuronhoz csatlakozik

   c. Kimeneti réteg: az itt található neuronok a külvilág felé továbbítják az információt. A feladatuk ugyanaz, mint a rejtett rétegbeli neuronoké. Ezzel a a külvilág felé továbbítják az információt, jellegükben és feladatukban nem különböznek a többi neurontól

A legtöbb esetben az egyes rétegek között nincs visszacsatolás, ilyenkor előrecsatolt hálózatokról beszélünk, visszacsatolás esetén visszacsatolt hálózatokról. A visszacsatolásnak több esete is lehetséges, aszerint, hogy a visszacsatolás honnan történt.

Eszerint lehetséges egy rejtett réteg valamely neuronjának kimenetét a saját bemenetére (elemi visszacsatolás), egy előző réteg neuronjának bemenetére (rétegek közötti visszacsatolás), vagy egy ugyanabban a rétegben található neuron bemenetére visszacsatolni (laterális visszacsatolás).



Nem ellenőrzött tanulás 
Nem állnak rendelkezésünkre összetartozó be- és kimeneti adatpárok. A hálózatnak a bemenetek alapján kell valamilyen viselkedést kialakítani. Általában a hálózatoknak valamilyen összefüggéseket, hasonlóságokat kell felderíteniük a bemeneti adatokban. Ezeket a hálózatokat hívják önszerveződő hálózatoknak is.



A neurális hálózatok esetében leggyakrabban alkalmazott ilyen eljárások a Hebb és a verseng tanulás.


  Hebb tanulás 
Az eljárás biológiai analógián alapszik, két processzáló elem közötti súlytényez értéke a processzáló elemek kiemenetének szorzatával arányosan növekszik. A probléma az eljárással, hogy a súlyok a végtelenségig nhetnének, ezért általában valamilyen normalizált változatát használják a gyakorlatban.



Verseng tanulás
A verseng tanulás esetén a processzáló elemek közül egyet valamilyen szempont szerint kiválasztunk győztesnek, például a győztes kimenete 1 értéket vesz fel, míg a többié 0-t. A verseng tanulás célja a bemeneti mintatér tartományokra osztása úgy, hogy minden egyes tartományhoz tartozó bemenet esetén egy processzáló elem aktiválódjon. A kiválasztás történhet automatikusan is, ilyenkor a processzáló elemek között oldalirányú kapcsolatok vannak.


Analitikus tanulás
A megfelel viselkedés hálózatok kialakítása elméleti úton, a feladatból meghatározható, tehát valójában nem is tanulás történik ebben az esetben. Ilyenkor a tanító pontokból közvetlenül, analitikus összefüggéseken keresztül határozzuk meg a hálózat súlyait. Némely esetben valamilyen energiafüggvény képezi a súlyok meghatározásának alapját.


 Többréteg perceptron hálózatok (MLP - multi-layer perceptrons)

A gyakorlatban legtöbbször alkalmazott struktúra. A neurális hálózatok újrafelfedezése akkor kezdődött, amikor a 80-as évek elején felfedezték a tanítására alkalmas hibavisszaterjesztéses algoritmust. A többrétegű perceptron hálózatokban perceptronokat kötünk össze, azonban az alkalmazott nemlinearitás valamilyen folytonosan differenciálható függvény (pl. szigmoid típusú). A súlymódosítást ebben az esetben szintén az LMS algoritmussal végezzük. A többrétegű hálózatok egyes rétegeiben egyszer perceptronok vannak összekötve.
A perceptronok kimenete, mint említettük, folytonos, mindenütt diferenciálható nemlinearitás. A többrétegű hálózatok rétegeinek neuronszáma eltér lehet.




A hálózat méretének megválasztása A rétegek számának, az egyes rétegeken belüli neuronok számának meghatározására nincs egyértelmű módszer. Általánosan elmondható, hogy a több réteg alkalmazása könnyítheti a feladat megoldását, illetve rétegenként kevesebb processzáló elem is elegendő lehet. Kétféle módszer terjedt el a hálózat méretének meghatározására. Az első szerint egy nagyobb hálózatból kiindulva próbáljuk meg csökkenteni annak méretét, a másik szerint egy kisebb hálózat bővítésével próbálunk eljutni a megfelel megoldásig.



A tanulási aránytényező megválasztása Nagyobb értékek választásakor a tanulás konvergenciája gyorsabb lehet, de a minimumhely közelében problémák mutatkozhatnak, st egyes esetekben divergenciához is juthatunk. Kisebb aránytényez választása esetén a konvergencia lassabb, de a minimumhely megtalálása pontosabban lehetséges. Általában célszer adaptív megoldásokat alkalmazni, ahol a tanulási aránytényez lépésenként változik, sőt akár rétegről rétegre is.


A kezdeti súlyok megállapítása Amennyiben rendelkezünk a problémáról valamilyen előzetes ismerettel, úgy a kiindulási súlyokat érdemes ennek megfelelően megválasztani. Általában azonban ilyen ismereteink nincsenek, így a legmegfelelőbb a kezdeti súlyok véletlenszerű meghatározása. Amennyiben a tanítás sikertelen, célszer más súlyokkal megpróbálni.



A tanító lépések száma A tanító lépések száma nem határozható meg előre, azonban figyelnünk kell arra, hogy a hálózat túltanulhatja magát, ami az általánosítóképesség rovására megy.



A megtanított hálózat minősítése A megtanított hálózat minősítése a hálózat ismeretlen adatokra adott hibája alapján lehetséges. Amennyiben a hiba elfogadható a tanítás (a struktúra megválasztása) sikeres volt.



A tanító mintahalmaz A hálózat tanításához szükséges minták száma természetesen függ a feladattól, de elmondható, hogy a legtöbb esetben kevés minta áll rendelkezésre. A tanító mintakészletet több részre szokták osztani, amelyek a hálózat tanításánál, és a tanítás sikerességének minősítésénél lehetnek fontosak. A tanító készletet használjuk a tanításra, míg a kiértékel mintakészletet a tanítás kiértékelésére.
A hálózat általánosítóképessége miatt várható, hogy ezeket a mintákra is helyes választ ad. A kiértékel mintakészlet felhasználása is lehetséges a tanítás során. Szokás még egy teszt mintakészlet meghatározása is, amelyet a tanításnál egyáltalán nem használunk fel. Kevés adat esetén a csoportok elemeit cseréljük (cross validation), és minden mintát felhasználunk tanításra és kiértékelésre is.



 Backpropagation változatok A tanítási algoritmus előbb bemutatott változata viszonylag lassú konvergenciát biztosít . A konvergencia gyorsítására, a lokális minimumba való beragadás elkerülésére különböző módszereket dolgoztak ki.



2019. november 20., szerda

Python modul listázás installálás uninstallálás

A python fejlesztői környezet hibátlan működéséhez több beállítási lépés is szükséges.


Python modul/packages  utvonal környezeti változó : $PYTHONPATH




Modul installálása:


 Goggle colab esetén:


!pip install networkx==1.11

!pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.4.0-{platform}-linux_x86_64.whl torchvision



Python Modulok használata:


>>> import math  ## Matematikai függvények modul importja
>>> dir( math )  ## importált matematikai föggvények listája
['__doc__ ', '__file__ ', '__name__ ', 'acos ', 'asin ', 'atan ', 'atan2 ',
'ceil ', 'cos ', 'cosh ', 'degrees ', 'e', 'exp ', 'fabs ', 'floor ',
'fmod ', 'frexp ', 'hypot ', 'ldexp ', 'log ', 'log10 ', 'modf ', 'pi ',
'pow ', 'radians ', 'sin ', 'sinh ', 'sqrt ', 'tan ', 'tanh ']


>>> help(math)
Help on built-in module math:

NAME
    math

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.

NameError: name 'help' is not defined // hiba üzenet esetén --> from pydoc import help

Python programon belülről:


try:
    import zumba
except ImportError:
    from pip._internal import main as pip
    pip(['install', '--user', 'zumba'])
    import zumba



Modul elérési utonalak lekérdezése:


Pythonból:


import sys
## Path kiíratása
print(sys.path)
print('\n'.join(sys.path))



## Path bővítése
sys.path.insert(0, "c:\\Users\\kecskemetil\\Documents\\kl_p\\prg\python37\\tkinter")



## Modulok listája
import sys as s
import pprint
print('\n modulok : ', s.modules)


## Modulok listája2.
print('\n dir : ',dir())
print('\n dir main : ',dir("__main__"))



## pl.: pretty print module keresési utvonalai
pprint.pprint( s.path)
pprint.pprint(s.modules)


##
help("modules")



 CMD konzol ablakban:

## modulok listázása PIP-el
pip list

pip freeze



--c:\Users\kecskemetil\Documents\kl_p\prg\python37\Lib\site-packages\beautifulsoup4-4.8.1.dist-info\


pip install torch==1.2.0+cpu torchvision==0.4.0+cpu -f  https://download.pytorch.org/whl/torch_stable.html


 CMD konzol ablakban Uninstall 


pip uninstall module

pip uninstall ttr.rdstmc



Uninstall művelet a könyvtár törlésével:

--c:\Users\kecskemetil\Documents\kl_p\prg\python37\Lib\site-packages\beautifulsoup4-4.8.1.dist-info\



 Goggle colab-al unisnstall:

!pip uninstall networkx -y





 Installásás Colab:


!wget https://repo.anaconda.com/archive/Anaconda3-5.2.0-Linux-x86_64.sh && bash Anaconda3-5.2.0-Linux-x86_64.sh -bfp /usr/local



 Istallálás tesztje colab-ban:


!conda info --all

!conda list



 Conda-ban install és uninstall művelet:


pip install cx_Oracle
pip uninstall cx_Oracle

----
conda install opencv
conda install cv2
conda search cv
---
conda config --add channels conda-forge
---
conda install -c menpo opencv

conda install -c menpo opencv3
conda install -c conda-forge opencv

conda install --channel https://conda.anaconda.org/menpo opencv3

conda install -c anaconda mkl
conda install -c pytorch pytorch torchvision


anaconda show menpo/opencv3



 Környezet létrehozása aktívvá tétele és irányított installálás

conda create -n pytorch_env python=3.5
source activate pytorch_env
conda install -c soumith pytorch
python



 Python modulok installálása és modulok uninstall-ja



 $ python

 >> import module
 >> print module.__file__
 '/some/directory'
--
 >> import package
 >> print package.__path__

----
pip install module
pip uninstall module



---- Python modulok listája

print(help('modules'))
print(dir())
print(dir("__main__"))
--
import sys
import pprint
pprint.pprint(sys.path)  # python modulok keresési utvonalai
--
pprint.pprint(sys.modules) # python modulok listája
---
import sys as s
print(s.modules.keys())
---

---- Anaconda modulok listája

conda list           ## telepitett modulok listája

conda list -n myenv  ## virt.environment : myenv telepitett modulok listája

conda update module  ## modul frissitése

conda update python  ## python verzio frissitése

conda update conda   ## conda verzio frissitése

conda remove -n myenv scipy ## virt.environment : myenv telepitett modul törlése

conda remove scipy   ## telepitett modul törlése


  COLAB modulok listája, install és uninstall-ja


!pip install module  ## modul telepítése
!apt-get install module ## modul telepítése
!apt-get install graphviz -y

## modulok listája
import sys as s
print(s.modules.keys())

!pip install networkx==1.11  ## konkrér verzioju modul telepítése

!pip install -e module  ## új modul verzio telepítése

!pip uninstall module -y ## modul törlése


!conda info --all
!conda list



!ls     ## könyvtár listázás
!mkdir  ## könyvtár létrehozás
!cat /proc/cpuinfo  ## cpu info
!cat /proc/meminfo  ## memoria info



!python3 /content/drive/Project/script.py  ## bachelt futtatás



 Van e TPU-nk lekérdezése colab-alatt


import os
if 'COLAB_TPU_ADDR' not in os.environ:
  print('Not connected to TPU')
else:
  print("Connected to TPU")



2019. november 9., szombat

BI DWH foglamak

Az üzleti intelligencia fogalma:
Olyan módszerek, fogalmak halmazát jelenti, melyek a döntéshozás folyamatát javítják
adatok és ún. szakterület alapú rendszerek használatával.


A "szakterület rendszer" fogalma a következő alrendszereket foglalja magába:
- Vezetői információrendszerek (Executive Information Systems);
- Döntéstámogató rendszerek (Decision Support Systems, DSS);
- Vállalat irányítási információrendszerek (Enterprise Information Systems);
- Üzleti információ elemző rendszerek (Online Analitical Processing (OLAP));
- Adat és szövegbányászat;
- Adat vizualizáció
- Térinformatikai rendszerek (Geographic Information Systems, GIS).




Előrejelző elemzéseknél egy modell felállítása a cél, mellyel múltbeli adatokból
következtethetünk jövőbeli eredményekre. Ilyen modellel lehetséges pl. egy változó
értékének becslése több változóból úgy, hogy megvizsgáljuk milyen összefüggés volt
a múltban a kulcsváltozó és a többi változó között. A már rendelkezésre álló
adatokra építve tehát felállítható egy előrejelző modell.

A bankok ügyféladatait felhasználva ilyen modellel mérhető fel az egyes ügyfelek hitelkockázati mutatója, mely valamennyi ilyen esetre építve keres kapcsolatot a hitelkockázat és már egyéb
változók – nem, kor, jövedelem, adósság, betétállomány, folyószámla – között.



Előrejelző modellek épülhetnek statisztikai regresszióra vagy osztályozó
(classification) technikákra, mint pl. döntési fa vagy neurális háló, de alkalmazható
az un. memória-alapú következtetés (memory-based reasoning) technikája is. A
regressziós eljárások közül a logisztikus regresszió, az osztályozó technikák közül
mind a döntési fa, mind a neurális háló módszerek alkalmasak nem lineáris
összefüggések felismerésére.


A statisztikai regresszió a független és függő változók közötti összefüggéseket
vizsgálja és a kapcsolatot leíró két-vagy többváltozós függvényt keresi. Egyszerűbb
formája a lineáris regresszió, amikor lineáris kapcsolatot feltételezünk a változók
között, s a folytonos eredményváltozó értéke egy vagy több független változó
lineáris függvényeként alakul ki.

Logisztikus regressziónál ugyanakkor az eredményváltozó mérési szintje bináris vagy ordinális változó, s keresett kapcsolat lehet nemlineáris is. Logisztikus regressziót alkalmaznak bankok, biztosítók
Az ügyfélkockázat-elemzésénél, de az egészségügyben a különböző rizikófaktorok
ismeretében a betegségek kialakulásának valószínűségét is ezzel az eljárással lehet
megállapítani.

A regressziós technikák két csoportba oszthatók a függő és független változók
között fennálló összefüggések milyensége alapján: lineáris és nemlineáris regresszió.

A legelterjedtebb regressziós technika a lineáris regresszió, mely a függő változót
független változók lineáris kombinációjaként becsli

A függő és független változó között azonban előfordulhat, hogy bonyolultabb, nem lineáris összefüggés van.
Ilyen esetben használhatóak a nemlineáris regressziós modellek, mint a paramétereiben
lineáris regresszió vagy a paramétereiben nemlineáris regresszió.

A döntési fa felépítése során az egész adathalmazt bontjuk részekre olyan változók
mentén, amelyek feltehetően szoros kapcsolatban vannak a kulcsváltozónkkal. A fa
ágainak minden elágazásánál egyszerű igen/nem vagy több választást lehetővé tevő
(multiple choice) kérdésekkel bontjuk további részekre a halmazt.
Az így kialakított döntési fa felhasználásával új adatok felvételekor a megfelelő ágat végigkövetve
becslést kaphatunk a kulcsváltozó lehetséges értékére.




Adatbázis anomáliák kiküszöbölése: normálforma
- 1NF: reláció mezői elemi értékek
- 2NF: 1NF és egyik mezőérték meghatározásához összetett kulcs kell, akkor másikhoz is ez kell
- 3NF: 2NF és nem kulcs jellemzői függetlenek egymástól
- BCNF: 3NF és egyetlen nem kulcs sem része egy összetett kulcsnak (nincs kulcstörés)
- 4NF: csak akkor áll fenn A1A2AN › B1B2BN, ha A1A2AN szuperkulcs





DWH építés alapok, fogalmak 2



- Adatbázis: együtt tárolt, egymással összefüggő adatok rendszere.


- Adatbázis struktúrája : az adatok meghatározott szerkezet szerint kerülnek tárolásra, és ezt a szerkezetett nevezzük így.


- Séma : Az adatbázis struktúra (szerkezet modell) leírását szintén az adatbázisban tárolják, ezt az adatbázis sémájának nevezzük


- Metaadatok : a séma leírására szolgáló adatokat szokás így hívni.


- Adatmodellezés: olyan eljárás, melynek során a valós világ tényeit és összefüggéseit tükröző adatok lényeges sajátosságait
és lényeges összefüggéseit emeljük ki. Eredménye az adatmodell.


- Egyedek: azokat a dolgokat, amelyek adatait le szeretnénk írni, egyedeknek, vagy objektumoknak nevezzük. Ezzeket tulajdonságokkal, attribútumokkal írjuk le.


- Kulcsok : egy tulajdonság, vagy a tulajdonságok egy csoportja egyértelműen meghatározza, hogy az egyed melyik értékéről,
vagyis az egyedhalmaz melyik eleméről van szó, akkor ezeket a tulajdonságokat kulcsnak, vagy azonosítónak nevezzük.


Ha a kulcs egyetlen tulajdonság, akkor egyszerű kulcsnak nevezzük, amennyiben több tulajdonság alkotja a kulcsot, akkor összetett kulcsról beszélünk.

Szelektivitás (Selectivity): A szelektivitás mindig szűrőfeltétel(ek)hez kötődik, és azt mutatja meg,
hogy sorok egy halmazából hány felel meg a feltételnek.

Számosság (Cardinality): A számosság alatt a halmazban található elemek számát értjük. Beszélhetünk
tábla számosságáról (ez a sorok számát jelenti), vagy oszlopok számosságáról, (ekkor az
oszlopban előforduló különböző elemek számára gondolunk).


Az adatmodell elkészítése során meg kell adnunk az adatokra vonatkozó megszorításokat is, ezek szintén a séma részei lesznek.


A legfontosabb megszorítástípusok:
- Kulcsok: a megszorítások között szokás megadni az egyedhalmazok kulcsát.

- Egyértékűségi megszorítások: megköveteljük, hogy egy egyedhalmazon belül
egy adott tulajdonság értéke minden egyednél különböző legyen. Ennek
speciális esetei a kulcsok, de nem azonosító tulajdonságnál is előfordulhat
ilyen megszorítás, például egy hallgató egyedhalmaz kulcsa a hallgatókód, de
a személyigazolvány-számnak is minden egyednél egyedinek kell lennie.

- Hivatkozásépség-megszorítások (referenciális integritás): megköveteljük,
hogy egy hivatkozott érték szerepeljen az adatbázisban. Például egy hallgató
nem vehet fel olyan tantárgyat, amely nem szerepel a tantárgyak
egyedhalmazában.

- Értékkészlet-megszorítások: egy tulajdonság értékeit csak egy meghatározott
halmazból veheti fel, például az érdemjegy csak 1, 2, 3, 4, 5 lehet.

- Általános megszorítások: tetszőleges követelmények, amelyeket az adatokkal
szemben támasztunk. Például, egy dátum nem lehet későbbi az aktuális
dátumnál.



- A relációs adatmodell az adatok táblázatos ábrázolásán alapul.
Ebben az adatmodellben a reláció egy névvel ellátott táblázat.
Egy táblázat sorai egy egyedhalmaz egyedeinek leírását tartalmazzák.


-- adattárház és adatpiac különbség
- Az adattárház : elemzési és lekérdezési céllal (OLAP [online analitical processing] funkciokkal) létrehozott speciális adatbázis.
Az adattárház nem más, mint adatpiacok összessége. (adat gyűjtő, tisztító, egyesítő, ripotoló elemző rendszer)

- Az adatpiac : egy kisebb adattárház, és általában csak egy-egy témával kapcsolatos adatokat tartalmaz,
pl. egy cég egyik osztályának működése során előállt adatokat.


--  A multidimenzionális modell szemantikai rétegének alapfogalmai a következők:

Tényadatok (~mutatószámok): azok a mérhető, numerikus adatok, amelyeket elemezni és ehhez tárolni szeretnénk.
Ilyenek például az árbevétel, súly, eladott darabszám, nyereség, raktárkészlet stb.

Dimenzió (~jellemző): azok a tulajdonságok, amelyek szerint a tényadatokat csoportosítani, jellemezni tudjuk.
A dimenziók egymástól független (bár nem feltétlenül teljesen független, ortogonális) jellemzői egy-egy tényadatnak.
Dimenzió lehet például idő, hely, termék, alapanyag, szállító neve, raktár, költségnem, költséghely stb.

Tag: a dimenzió egy érték-előfordulása, azaz egy koordináta érték a dimenzió él mentén.

Hierarchia: a dimenziók elemei hierarchiákba rendezhetők, adott dimenzió esetén az egyes tagok közötti hierarchikus kapcsolatrendszert írja le.
Ilyen hierarchikus szerkezet lehet például idő dimenzió esetén egy év – hónap – nap felbontás vagy egy irodai szoba esetén
egy épületegyüttes – épület – emelet – szoba felbontás. A dimenziók számára csak a kiválasztott adattárház-rendszer ad megszorítást.

Felbontás: az a legkisebb adategység, amely egységekben az adatot még elérhetővé szeretnénk tenni,
tehát amikor az adat jellemzéséhez minden dimenziót felhasználunk.
Adatkockánként több típusú tényadat is szerepelhet egymás mellett, ekkor azonban mindegyikük granularitása (felbontása) meg kell egyezzen.


-- legelterjedtebb műveletek a következők:
Aggregáció (roll up): csoportosításokat végzünk valamely dimenzió mentén (például városok helyett országok szerint nézzük adatainkat).
Lefúrás (drill-down) : az előzővel ellentétes művelet, amely csökkenti a csoportosítás szintjét, és egyre részletezettebben nézhetjük az adatokat.
Elforgatás (pivoting): az adatkocka elforgatását értjük alatta, az adatok multidimenzionális képét alakítja át például kétdimenziós táblázatba.
Szelekció (selection, filtering): egy adott dimenzió egy adott elemét kiválasztjuk, és a hozzá tartozó adatokat dolgozzuk fel,
 míg a többi adatot figyelmen kívül hagyjuk.
Szeletelés (slicing and dicing): a kocka szeletekre bontása. A szelekcióhoz hasonlóan azt értjük alatta, amikor egy adott dimenziót fix értékkel lekötünk,
és ily módon vizsgáljuk a kocka egy nézetét, egy szeletét. Dicing alatt a kocka egy részkockájának kivágását értjük.


-- b-fa index és bit map index :

B+ fa (Bayer fa): gyakorlatban ezt használják (pl. Oracle)
— az adatokra mutató pointerek mind a leveleken vannak
— gyors keresés, lognN lépés
— Könnyű karbantartás



Bitmap index
A bittérképes index haszna igazán olyan oszlopoknál mutatkozik meg amelyekben kevés a különböző érték,
viszont ezekből sok fordul elő, és az értékek egyenletes eloszlást mutatnak.
(pl.: CREATE BITMAP INDEX dwh.bidx ON dwh.tabla(color);

DWH építés fogalmai, elvei 1


- Csillagséma (star schema)
Modellünkben a tényadatok, mutatószámok játsszák a központi szerepet.
A ténytábla normalizálásaként a mutatószámok jellemzőit dimenziók szerint
egy-egy dimenziótáblában gyűjtjük össze, melynek minden elemét egy kulcs azonosít.
Általánosan is igaz, hogy a dimenziótáblák mérete a ténytábla méretéhez képest nagyságrend(ekk)el kisebb


-- DW tervezés lépései
modellezendő üzleti folyamat kiválasztása  pl.: raktárkészlet nyilvántartások
felbontás (granularity) meghatározása      pl.: raktárkészlet termékenként, naponként, raktárhelyiségként, szállítóként, stb.
dimenziók meghatározása, kidolgozása       pl.: termék: név, súly, szín, beszerzési ár, stb.
tényadatok meghatározása                        pl.: raktári mennyiség, súly, érték, minőségi mutatók, stb.


A tervezés első lépése, hasonlóan az álatános  információs rendszerekhez,  itt is a 
lehetséges információigények meghatározása és elemzése. Ennek során kell
feltárni az adattárházban elhelyezendő adatelemeket, a felhasználók igényeinek
elemzésével. Meg kell győződni arról, hogy a megkívánt információ igények
mindegyike kielégíthető a modellbe bevont adatelemekkel.

A tervezés második lépése a  normalizált SDM modell felépítése. Ennek során egy
kiválasztott szemantikai modell segítségével felvázoljuk a modellben előforduló
egyedeket és  a köztük fennálló kapcsolatokat. A modell leírásához
felhasználhatjuk a már ismert SDM rendszereket, így például az ER modell is
alkalmazható e célra.

A tervezés harmadik lépése a tényadatok, vagyis a cellákba tárolandó adatelemek
kiválasztása. A tényadatoknak olyan mennyiségeknek kell lenniük, melyek értéke
igen vontos, meghatározó a vizsgált problématerület szempontjából, s amelynek
más mennyiségektől való függését vizsgáljuk.

A következő lépés a dimenziók feltárása. Ennek során kiválasszuk azon
mennyiségeket, melyek meghatározzák a cellák tartalmát. A cellaértékeknek ezen
mennyiségektől való függőségénekl a vizsgálata,eélemzése lesz majd elkérdezések
fő célja.


Eztkövetően kidolgozásra kerül az egyes dimenziókhoz tartozó  hierrachia
rendszer. Fel kell deríteni, hogymely dimenzióknál van lehetőség és szükség a
többszintű tagértékek kijelölésére. Ha definálható ilyen értékhierarchia, akkor meg
kell határozni az egyes szinteket leíró mennyiségeket, az egyes szintek
azonosítását.


A dimenziók vizsgálatának utólsó lépése az attributumok meghatározása. Ennek
érdekében meg kell vizsgálni, hogy milyen információkra van szüksége a
felhasználónak az egyes dimenziókat illetően, vagyis milyen struktúrát célszerű
felvenni a dimenzió tagértékek tárolására.

A tervezés utólsó lépése a változók megadása, vagyis a cellában tárolt tényadatok
struktúrájának leírása. A struktúra szerkezetéhez  a felhasználói igények elemzésén
keresztül juthatunk el.


-DW bővítés tervezés alapvetően első lépésekben különbözik csak a normál, tiszta lappal induló
tervezéstől. Az ilyenkor használatos lépések a következők:

- relációs modell elemzése, a fűüggőségi kapcsolatok feltáráa
- modell kiterjesztése a szükséges új elmekkel
- tényadatok kiválasztása
- dimenziók meghatározása
- dimenzió hierarchia kijelölés
- attributumok megadása
- változók meghatározása
- séma felrajzolása





-- teljesítmény javítás
- Denormalizáció
Denormalizáció alatt értjük azt az eljárást, mikor a ténytáblában redundánsan eltárolunk járulékos jellemzőket, olyanokat,
melyek a dimenziótáblákban egyébként szerepelnek. Például, a kiskereskedős példánál az elemzéseknél gyakran használják a termék dimenziót,
de abból csak a gyártó jellemzőt. Ekkor, ha a válaszidők nem megfelelőek, a ténytáblába mint oszlop bevesszük a "gyártó" jellemzőt,
így megspórolva egy join műveletet a kiértékelésnél, elbukva viszont tárterületet a redundancia miatt.
Az adattárház rendszerekre általánosan jellemző az elemzési hatékonyság miatti redundáns adattárolás.


- Aggregáció
Aggregáció alatt értjük azt, mikor az adatok valamely szempont szerinti felösszegzett változatát is eltároljuk az adatbázisunkban.
Ez jelentheti egy vagy több dimenzió elhagyását.
Nyilván az aggregációs szintek bevezetésével, használatával a válaszidők jelentősen javulhatnak egyes lekérdezéseknél,
igaz viszont az is, hogy az összegeket minden új adatelem beszúrásánál frissíteni kell.
A kocka materializációja alatt pedig azt értjük, hogy a lehetséges cuboid-ok közül melyeket tárolunk el fizikailag is.


- Particionálás
A ténytábla túl nagyra hízása a teljesítmény rovására megy. Ezt elkerülendő szokás a táblát több ténytáblára vágni,
melyek esetleg akár párhuzamosan is feldolgozhatók lehetnek.



- Több szállosítás
A feladat több processzoron is fut


- Tábla tömörítés (table compressio)
A tárolási blokkok duplikációinak (redundanciájának) megszüntetése blokk visszaállító szótáraksegítségével
Az ilyen tábla változtatása igen kültséges erőforrás szempontjából




--  adatok kinyerése és betöltése az adattárházba - Data Staging Area
ETL Tools: Extraction, Transformation and Load, vagyis olyan eszközök, melyek az adatok kinyerését, transzformációjátm tisztitását
és adattárházba töltését támogatják.

Adatkinyerés az operatív rendszerekből (extraction)
Adattranszformáció (különböző adatformátumok, mértékegységek, nyelvek stb.)
Adatminőség ellenőrzése, adattisztítás (cleaning)
Adatbetöltés az adattárház struktúráiba (loading)

- Adattöltések szabályozó mechanizmusai
"Push" adattöltés: Az operatív rendszerünket felkészítjük arra, hogy az adattárház számára adatokat gyűjtsön, adatokat továbbítson.
Ebben az esetben lentről-felfelé az operatív rendszer kezdeményezi az adatok továbbítását az adattárházba.

"Pull" adattöltés: Az adattárház a megfelelően beállított időintervallumban az operatív rendszerekhez intézett lekérdezésekkel frissíti az adatait.

- adattöltések megkülönböztetése a változások követésének szemszögéből.
Eszerint, ha az operatív rendszerben új vagy megváltozott adatokra vonatkozóan
  csak a változás valamilyen leírását továbbítjuk, delta-töltésről (a változásra utalva),
  ha az operatív rendszer adatait egy az egyben továbbítjuk, teljes-töltésről beszélhetünk.



 
  -- A betöltés folyamán az alábbi kiegészítő, kisérő tevékenységekre lehet szükség:
  - az adatok integritásának ellenőrzése.
- az adatértékek rendezése, a megfelelő tárolási pozició kikeresése
- az adatértékek indexelése, azaz az indexek aktualizáslása
- a kiszámítandó értékek frissítése



- Egyfázisú töltés
az adatokat közvetlenül a céltáblába töltjük;
minőségi teszteket végzünk;
a hibákat javítjuk DML utasítások segítségével, mielőtt a materializált nézetek frissítésre kerülnek;
ha nagyszámú törlés lehetséges, akkor a tárhely használata kedvezőtlen lehet, de a temporális terület használata és a töltési idő minimalizálható.


- Kétfázisú töltés
az adatok először egy átmeneti táblába kerülnek betöltésre;
minőség-ellenőrzési eljárásokat végzünk;
a céltáblákon a referenciális integritási megszorítások kikapcsolása, a célpartíciókon az indexek megjelölése UNUSABLE-ként;
az átmeneti táblából az adatok másolása a céltábla megfelelő partíciójába INSERT AS SELECT használatával, PARALLEL vagy APPEND hint-tel;
az átmeneti tábla eldobása.


A kétfázisú töltésre másik módszer lehet, amennyiben a céltábla particionált:
egy új (üres) partíció létrehozása a céltáblában;
az ALTER TABLE ... EXCHANGE PARTITION utasítással kerülnek be az átmeneti tábla adatai a céltáblába;
megszorítások engedélyezése, rendszerint a NOVALIDATE opcióval.
Az adatok betöltése és az indexek frissítése után az adatbázis működésre megnyitható.




BI informatikai fogalmak



Absztrakt osztály: Olyan osztály, amely nem példányosítható, mert van olyan metódusa, amely nincs az adott osztályban implementálva. Az implementálás - származtatás után - a utódosztályban történik meg.


Adatmező: Lásd adattag!


Adattag: (attribútum, adatmező): Az osztálydefiníció része, az osztály objektumainak (példányainak) egyedi jellemzőit, tulajdonságait tároló adattípus. Lehetnek példányszintűek és osztályszintűek is.


Aktuális paraméterlista: Kifejezések vesszővel ellátott felsorolása. Paraméterátadásnál az aktuális paraméterek típusának rendre  - tehát megfelelő sorrendben, páronként - meg kell egyeznie a formális paraméterlistában megadottakkal.


Attribútum: Lásd adattag!


Destruktor: A konstruktor által lefoglalt erőforrások felszabadítását végzi. A Java-ban automatikusan is megtörténik, ha egy objektumra minden hivatkozás megszűnik.

Dinamikus (késői) kötés: A hívott metódus futásidejű hozzárendelése az objektumhoz.

Egységbezárás: Adattagok és metódusok osztályba történő összezárását jelenti. Egy objektum (példány) állapotát (adattagjait) csak metódusai által módosíthatjuk.


Eljárás: Olyan metódus, amelynek nincs visszatérési értéke.


Formális paraméterlista: Típusokból és szintaktikailag lokális változónak minősülő adattagokból álló párosok, amelyek az aktuális paraméterlista felépítését meghatározzák.

Függvény: Olyan metódus, amelynek van visszatérési értéke.

Kivételkezelés: A program futása során keletkező hibák kiszűrését megvalósító olyan programszerkezet, amelyben a tevékenységeket végző programkód határozottan elkülönül az azokban előforduló hibák lekezelését végző programkódtól.


Konstruktor: Egy osztály olyan speciális metódusa, amely a példányosítást végzi. Egy osztálynak több - szigorúan azonos nevű - konstruktora is lehet.


Metódus (módszer): Az osztálydefiníció része, az osztály objektumainak viselkedését leíró programrutin. Lásd még osztályszintű metódus!


Metódus felülírása: Azonos nevű, de különböző formális paraméterlistával rendelkező metódusok. Dinamikus kötéssel jön létre.


Metódus túlterhelése: Azonos nevű, de különböző formális paraméterlistával rendelkező metódusok. Statikus kötéssel jön létre.


Módszer: Lásd metódus!


Objektum: Olyan programozási eszköz, amelynek neve, adattagjai által reprezentált állapota, és metódusaival jellemzett viselkedése van. Egy osztály konstruktoráltali példányosítása során jön létre.


Objektum-orientált programozás: Olyan programozási paradigma, amely a programot objektumokból építi fel. Az objektumok viselkedése adja a program működését.


Osztály: Olyan felhasználói típus (tervrajz), amely alapján objektumok (példányok) hozhatók létre. Legfontosabb részei a neve, adattagjainak és metódusainakdefiníciója.


Osztályszintű adattag: Olyan adattag, amely egy osztályon belül csak egyszer létezik, és magához az osztályhoz kapcsolódik. Lásd még példányszintű adattag!


Osztályszintű metódus: Olyan metódus, amely közvetlenül az osztályhoz kapcsolódik, nem pedig a példányokhoz. Az osztálymetódust az objektumok közösen használhatják.


Osztályváltozó: Lásd osztályszintű adattag!


Öröklődés: Az újrafelhasználás eszköze. Leszármazott (gyermek-, al-) osztály létrehozása már meglévő (szülő-, ős-) osztályból, amely során a leszárazott osztály örökli az ősosztály adattagjait és metódusait.


Paradigma: Személet- és gondolkodásmód, egy tudományos közösség tagjai által elfogadott értékek és módszerek összessége.


Példány: Lásd objektum!


Példányosítás: Egy osztály objektumának előállítása konstruktor segítségével.


Példányszintű adattag: Olyan adattag, amely egy osztály minden példányában egyedileg létezik, tehát a példányhoz kapcsolódik. Lásd még osztályszintű adattag!


Példányváltozó: Lásd adattag, példányszintű adattag!


Polimorfizmus: Egyrészt jelenti a metódusok felülírását (dinamikus polimorfizmus, újraimplementálás), amely során egy leszármazott osztályban felülírjuk (módosítjuk) az ősosztály egy metódusát, másrészt jelenti a metódusok túlterhelését (statikus polimorfizmus, többalakúság), amikor egy osztályon belül ugyanolyan néven több metódus is létezik, és csak formális paraméterlistájuk alapján különböztethetők meg. Statikus polimorfizmust valósítanak meg az osztályok konstruktorai is.


Statikus (korai) kötés: A hívott metódus fordításidejű hozzárendelése az objektumhoz.


Üzenet: Egy objektum metódusának másik objektum által történő meghívását jelenti. A megszólított objektum a kérés végrehajtásával válaszol az üzenetre.



Végleges osztály: Olyan osztály, amelynek metódusai nem definiálhatók felül, így az örököltetésük sem valósítható meg.
 


2019. október 1., kedd

Mesterséges neurális hálók

A mesterséges neurális hálózatról akkor beszélhetünk, ha a rendszer rendelkezik tanulási és predikciós algoritmussal és általában több rétegbe szerveződik.









A hálózat átalakításánál lényegében négy elemre kell koncentrálnunk:
 - a bemeneti mátrix,
 - súly mátrix,
 - az eltolás (bias),
 - az aktivációs függvény


Problémamegoldó folyamat lépések neurális háló használatnál:
 adathalmaz kiválasztása,
 modell kiválasztása,
 adatok előfeldolgozása,
 modell implementálása,
 modell hiperparaméter optimalizálása,
 tanító és teszt adatok cseréje,
 eredmények kiértékelése


Az adathalmaz kiválasztása :
 A bemenet a bemeneti értékeket jelenti vektor formájában.
 A súlyok jelentik a neurális hálózat paramétereit, ezeknek kívánjuk
 az iteratív tanítás során megtalálni a megfelelő értékeit (hiperparaméter).

 Adat tisztítás, megfelelően előkészített bemeneti adatok kiválasztása.
 Az előfeldolgozásra azért van szükség, mert általában a rendelkezésre álló adathalmaz hiányos,
 hibákkal, adat tüskékkel tűzdelt, zajos, és/vagy inkonzisztens.



A modell kiválasztása: 
 A leggyakrabban használt „építőelemek” struktúrák, háló architektúrák:
- az előrecsatolt,
- a rekurrens,
- a konvolúciós rétegek.


A különböző architektúrák jellemzően más problémák esetén teljesítenek jobban,
sőt építőelemekként kezelve őket, kombinálni is lehet ezeket.

Neurális hálózat kialakítása nagyon bonyolult.
A közkedvelt kódtárak segítségével (Microsoft Cognitive Toolkit és a TensorFlow)
is több száz sornyi kód szükséges egy neurális hálózat kialakításához.

Ez a mély-tanulással foglalkozó munkánkat a Keras jelentősen leegyszerűsíti.

A Keras nyílt forráskódú Python-kódtár, amely  a neurális hálózatok készítését támogatja,
egyszerűsíti le.


A Neurális hálózat tanítása
betanítható képek kategorizálására, szövegek hangulatelemzésére,
természetes nyelvi feldolgozásra és más olyan feladatokra,
amelyekben a mély-tanulás kiemelkedően eredményes.



A modell hiperparaméter optimalizálása
 Hálózat hangolása,ideális paramétereinek megtalálása, a hiperparaméter optimalizálása.
 Az munkát hiperparaméter optimalizációhoz Hyperopt és Hyperas könyvtárak használatával
 lehet egyszerűsíteni.






2019. szeptember 6., péntek

ODI hasznos sql-ek

--- ODI KM helye WIN: c:\Oracle\ODI122\odi\sdk\xml-reference\ACT_Add_Alternate_Key.xml



--- munkamenet futtáskor futtatott SQL maszk

select sess_no, def_txt as sqltxt, NNO,               NB_RUN,            SCEN_TASK_NO,             TASK_BEG,         TASK_END,                TASK_DUR,        TASK_STATUS, NB_ROW, NB_INS

from ebh_odi_repo.SNP_sess_task_log where 1=1

and sess_no = 39

and def_txt is not null and def_txt like 'insert%'

--  order by length(def_txt) desc

-----------------

--- munkamenethez tartozó paraméterek

select sess_no, startup_variables as act_vars, SESS_NAME, SESS_BEG, SESS_END, SCEN_NAME, NB_ROW, NB_INS, NB_UPD, NB_DEL, NB_ERR, SB_NO

from EBH_ODI_REPO.SNP_SESSION

where sess_no = 39





import groovy.sql.Sql

import oracle.odi.domain.project.finder.IOdiVariableFinder

import oracle.odi.domain.project.finder.IOdiSequenceFinder



import groovy.swing.SwingBuilder



tme = odiInstance.getTransactionalEntityManager()

varList = ((IOdiVariableFinder) tme.getFinder(OdiVariable.class)).findAll()

seqList = ((IOdiSequenceFinder) tme.getFinder(OdiSequence.class)).findAll()

actVarMap = new HashMap<String,String>()



// SQL

url = "jdbc:oracle:thin://@Aszerver:1152/D10"

user = "REPO"

pw = "Ejelszo"

sql = Sql.newInstance(url, user, pw, "oracle.jdbc.driver.OracleDriver")



// ehhez a sessionhoz tartozó logot dolgozza fel (régi működés)

// *** ha -1, akkor az sqltxt változóban megadott stringet dolgozza fel ***

tmp_sess_id = 11611 //-1

actual_vars_fl = true // ha igen, akkor az aktuális paraméterekkel helyettesít, egyébként az alapértelmezettekkel



if ( tmp_sess_id < 0 ) {



  sqltxt = """



  """



} else {



  stmt = """

         select def_txt as sqltxt

         from SNP_sess_task_log

         where sess_no = :p_sess_id

           and def_txt is not null

         order by length(def_txt) desc

         """;



  stmt2 = """

        select startup_variables as act_vars

        from EBH_ODI_REPO.SNP_SESSION

        where sess_no = :p_sess_id

        """;



  sqltxt = sql.firstRow(stmt, [p_sess_id: tmp_sess_id]).sqltxt.getAsciiStream().getText() // SQL log

  tmp = sql.firstRow(stmt2, [p_sess_id: tmp_sess_id]).act_vars.getAsciiStream().getText() // aktuális paraméterek

  sql.close()



  for ( l in tmp.split('\n') ) {



    tmp2 = l.split('=')



    try {

      actVarMap.put(tmp2[0], tmp2[1]) 

    } catch (Exception e) { null }

  }



}







sqltxt = sqltxt.replace(':', '')

sqltxt = sqltxt.replace('#', '')





if ( actual_vars_fl == true ) {

 

    // legújabb működés

    // aktuális változók

    for ( i in actVarMap ) {

 

      from = i.key

      to = i.value + ' /*' + i.key + '*/'

      sqltxt = sqltxt.replaceAll('\\b' + from + '\\b', to) // regexp word boundary check

    }



}

else {

    // változók

    for ( i in varList ) {

   

      from = i.getQualifiedName()

   

    /* a régi KM modulhoz kellett

      if ( from == 'GLOBAL.P_EFFECTIVE_LOAD_DATE' ) {

        pre = "to_date('"

        post = "', 'YYYYMMDDHH24MISS')"

      } else {

        pre = ''

        post = ''

      }

    */

   

      //to = pre + i.getDefaultValue() + post + ' /*' + i.getQualifiedName() + '*/'

      to = i.getDefaultValue() + ' /*' + i.getQualifiedName() + '*/'

   

      //sqltxt = sqltxt.replace(from, to)

      sqltxt = sqltxt.replaceAll('\\b' + from + '\\b', to) // regexp word boundary check

    }

}



// szekvenciák

for (i in seqList ) {



  from = i.getQualifiedName() + '_NEXTVAL'

  to = 'EBH_DW.' + i.getNativeSequenceName() + '.nextval'



  //sqltxt = sqltxt.replace(from, to)

  sqltxt = sqltxt.replaceAll('\\b' + from + '\\b', to) // regexp word boundary check



}



print sqltxt + '\n;\n\n'



def swing = new SwingBuilder()







// ez nem is kell

swing.edt{

    frame( title: 'Session: ' + tmp_sess_id, pack:true, show:true ){

        panel(){

            scrollPane( preferredSize:[800, 800] ){

                editorPane( contentType: ("text/sql"), text: sqltxt)

            }

        }

    }

}


------

import groovy.sql.Sql

import java.sql.Driver

//---------------------

class kl_db_minta_csere {

   static void main(String[] args) {

//-------------------

def words = []

def readies = []

def di_words =[][]

//-------------------

try {

def driver = Class.forName('oracle.jdbc.OracleDriver').newInstance() as Driver

def props = new Properties()

props.setProperty("user", "user")

props.setProperty("password", "KLjelszo")

def conn = driver.connect("jdbc:oracle:thin:@ora:1152: T10", props)

def sql = new Sql(conn)

def sql_parancs ="""

Select a.object_name,

       a.object_long_name,

       se.startup_variables,

       st.def_txt,

       st.error_message     As task_error

  From ebh_odi_repo.snp_step_log      s,

       ebh_meta.mt_lp_all_executions  a,

       ebh_odi_repo.snp_step_report   sr,

       ebh_odi_repo.snp_scen          sc,

       ebh_odi_repo.snp_session       se,

       ebh_odi_repo.snp_sess_task_log st

Where s.sess_no = a.external_session_id(+)

   And s.sess_no = sr.scen_run_no

   and SR.SCEN_NO = SC.SCEN_NO(+)

   And s.step_beg > Date '2019-03-16'

   And s.sess_no = se.sess_no

   and S.SESS_NO = ST.SESS_NO

   and sc.scen_name like 'MAP_B%'

   and st.col_conn_name ='EDW' and st.def_conn_name ='EDW'

   and DEF_TXT like 'insert %'

   and OBJECT_TYPE_NAME ='SCENARIO'

   and s.nb_row = 22065

   """

//--------------------------

def results = sql.firstRow( sql_parancs )  ///sql.rows( sql_parancs )

def parameters = " "

def sql_nyers = " "

sql_nyers = results['def_txt'].asciiStream.text                           /// sql (CLOB tipusu mező miatt konverzió

parameters = results['startup_variables'].asciiStream.text.split(/\n/)    /// parameter tömbösítás



//---------------------

   parameters.each { parameter ->

//      println(parameter)

      di_words.add(parameter.split(/=/))

   }



//--------------------

      di_words.each { csere ->

        if ( csere[0].length() > 1 ){

            sql_nyers = sql_nyers.replaceAll(":" + csere[0], csere[1])

//            print( csere[0])

//            print(' --> ')

//            println( csere[1])

        }     

      }

      readies.add(sql_nyers + "\n")

 



//------------------------

/*

readies.each {

    println it    //// tartalmának kiírása

}

*/

///------------------------



def file = new File("out2.txt")

file.write ""

readies.each {

   file.append(it)

}

//---------------------------

println file.text  //// file tartalmának kiírása

//---------------------------



conn.close()



} catch(Exception ex) {

         println("HIBA: az adat nincs meg");

}



/// Erőforrás felszabadítás

//sql.close()



}

}


-----


 Select a.object_name,

       a.object_type_name,

       a.object_long_name,

       sr.step_name,

       sc.scen_name,

       s.step_beg,

       s.step_end,

       s.step_dur,

       s.step_status,

       s.nb_row,

       s.error_message      As error_msg,

       se.startup_variables,

       s.sess_no,

       a.id,

       a.parent_id,

       a.sid,

       a.status,

       a.error_message,

       a.record_count,

       sr.lschema_name,

       sr.mod_code,

       sr.table_name,

       sr.res_name,

       st.task_name3,

       st.col_conn_name,

       st.def_conn_name,

       st.task_beg,

       st.task_end,

       st.task_status,

       st.nb_row,

       st.def_txt,

       st.error_message     As task_error

  From ebh_odi_repo.snp_step_log      s,

       ebh_meta.mt_lp_all_executions  a,

       ebh_odi_repo.snp_step_report   sr,

       ebh_odi_repo.snp_scen          sc,

       ebh_odi_repo.snp_session       se,

       ebh_odi_repo.snp_sess_task_log st

Where s.sess_no = a.external_session_id(+)

   And s.sess_no = sr.scen_run_no

   and SR.SCEN_NO = SC.SCEN_NO(+)

   And s.step_beg > Date '2019-03-16'

   And s.sess_no = se.sess_no

   and S.SESS_NO = ST.SESS_NO

   and sc.scen_name like 'MAP_BPI_T%'

   and st.col_conn_name ='EDW' and st.def_conn_name ='EDW'

   and DEF_TXT like 'insert %'

   and OBJECT_TYPE_NAME ='SCENARIO'

   and sr.table_name ='BPI_FE_BEA_TRAN_HISTORY'





def words = []

def readies = []

def di_words =[][]

//-------------------

new File( 'star_values.txt' ).eachLine { ///// line ->  || it

                                         ///// words << it || words.add(it)

    if ( ( it.substring(0,1) == '"') && (it) )  {

       words.add(it.substring(1,))       // Idézőjel kezdet kihagyása

       di_words.add(it.substring(1,).split(/=/))

    } else {   

       words.add(it)

       di_words.add(it.split(/=/))

    }

}

//--------------------

new File( 'def_txt.txt' ).eachLine { line ->

      di_words.each { csere ->

        if ( csere[0].length() > 1 ){

            line = line.replaceAll(":" + csere[0], csere[1])

        }     

      }

      readies.add(line + "\n")

}

readies.each {

    println it

}

///------------------------



def file = new File("out.txt")

file.write ""

readies.each {

  //// file.write "First line\n"

  //// file << "Second line\n"

  //// file.append("hello\n")

   file.append(it)

}

//---------------------------

println file.text

2019. július 28., vasárnap

Szövegelemzés Python -nal

Szövegelemzési fogalmak:

 TF-IDF : term frequency - inverse document frequency. Ez az érték jellemzi egy szó fontosságát az adott dokumentumban. A fontosság növekszik a szó újabb és újabb előfordulásával, de csökken, ha az adott korpuszon belül egyre több dokumentumban jelenik meg. Az alábbi esetben a dokumentum egy darab hozzászólás, a korpusz pedig a hozzászólások halmaza.
Használat során a magas tf-idf érték magas kifejezés gyakorisággal és alacsony dokumentum gyakorisággal jár együtt, tehát így kiszűrhetőek a gyakori kifejezések. Egy-egy kifejezés tf-idf értéke akkor nagyobb, mint 0, ha az idf logaritmus belsejében az érték nagyobb, mint 1.
Attól függően, hogy a nevezőhöz hozzáadunk-e 1-et, egy olyan kifejezésnek, amely minden dokumentumban szerepel, nulla vagy negatív lesz a tf-idf értéke.



Absztrakt adattípus : amely absztrakt adatok halmazát  adja meg (definiálja), nem törődve a konkrét gépi megvalósítással.
Pl.: tömb, lista, verem, sor, halmaz, kupac, fa, gráf, hálózat, binomiális kupac


Algoritmus : meghatározott számítási eljárás, a számítási probléma megoldási eszköze
Karakterizáló paramétere 
1.A kiinduló adatok lehetséges halmaza
2.A lehetséges eredmények halmaza
3.A lehetséges közbülső eredmények halmaza
4.A kezdési szabály
5.A közvetlen átalakítási szabályok
6.A befejezési szabály
7.Az eredmény kiolvasási szabály




Algoritmus hatékonysági jellemzője:
A egy algoritmust, x egy bemenő adatot, n=|x | a bemenő adat méretét,D a lehetséges bemenő adatok halmazát.
Legyen TA(x) az A algoritmus végrehajtásának időigénye,  SA(x) az A algoritmus tárigénye az x bemenet esetén.
 Az algoritmus időbonyolultsága és tárkapacitás bonyolultsága


Az olyan halmazt, amely az őt felhasználó algoritmus során változik (bővül, szűkül, módosul) dinamikus halmaznak nevezzük. A dinamikus halmazok elemei tartalmazhatnak:- kulcsmezőt, - mutatókat (pointereket), amelyek más elemekre mutatnak. (pl: a következő elemre) 



A verem (stack) olyan dinamikus halmaz, amelyben előre meghatározott az az elem, melyet a TÖRÖL eljárással eltávolítunk. Ez az elem mindig a legutoljára a struktúrába elhelyezett elem lesz.



A láncolt lista (linked list) olyan dinamikus halmaz, melyben az objektumok, elemek lineáris sorrendben követik egymást. A lista minden eleme mutatót tartalmaz a következő elemre. 



Azt a rendező eljárást, melynek végén az azonos értékű kulcsok sorrendje megegyezik az eredetivel. stabil eljárásnak nevezzük.



Shell rendezés módszere: 

A buborékrendezésnél tapasztalt lassú helyrekerülést igyekszik felgyorsítani azáltal, hogy egymástól távol álló elemeket hasonlít és cserél fel. A távolságot fokozatosan csökkenti, míg az 1 nem lesz. Minden növekmény esetén beszúrásos rendezést végez az adott növekménynek megfelelő távolságra álló elemekre. Mire a növekmény 1 lesz, sok elem már majdnem a helyére kerül.


Négyzetes rendezés módszere:
Felosztjuk az a forrás tömböt √n számú √n elemet tartalmazó részre (alcsoportra). Mindegyikből kiemeljük a legkisebbet. (Ez lesz a főcsoport.) Kiválasztjuk a legkisebbek legkisebbikét (a legkisebbet a főcsoportból) és azt az eredmény tömbbe írjuk, a főcsoportból eltávolítjuk. Helyére abból az alcsoportból ahonnan ő jött újabb legkisebbiket emelünk be a főcsoportba. Az eljárást folytatjuk, míg az elemek el nem fogynak.



Számjegyes rendezés módszere:
Azonos hosszúságú szavak, stringek rendezésére használhatjuk. (Dátumok, számjegyekből álló számok, kártyák, stb.) Legyen d a szó hossza, k pedig az egy karakteren, mezőben előforduló jegyek, jelek lehetséges száma, n pedig az adatok száma. 



 Edényrendezés módszere:
Feltételezzük, hogy a bemenet a [0, 1) intervallumon egyenletes eloszlású számok sorozata. Felosztjuk a [0, 1) intervallumot n egyenlő részre (edények). A bemenetet szétosztjuk az edények között, minden edényben egy listát kezelve. Az azonos edénybe esőket beszúrásos módon rendezzük. A végén a listákat egybefűzzük az elsővel kezdve. 


A szöveg elemzési módszerek között megkülönböztetünk:

 - inkrementális
 - dekrementális módszereket.


Az inkrementális módszerek lényege, hogy egy új hivatkozást azonnal osztályhoz rendel, vagy új osztályt hoz belőle létre, ha az mindentől nagyon távol esik.


Az inkrementális hozzárendelés lépései: 
Azonosítás: - a hivatkozási helyek és szövegrészek kiemelése.
Normalizálás: - a hivatkozó szövegek transzformációja (egységes alakra hozása és tisztítása) és részekre bontás.
Távolságképzés: - az adott kiemelt hivatkozási hely és az osztályok reprezentánsai távolságának kiszámítás.
Hozzárendelés: - a hivatkozási helyek (és ezzel a hozzászólás) osztályhoz rendelése (vagy új osztály létrehozása).
Reprezentálás: - új osztály létrehozása vagy régi osztály bővítése esetén reprezentáns választása.


A szövegek közötti távolság számítására többféle metrikát használhatunk.

Hamming távolság: az azonos pozícióban lévő, de eltérő betűk száma. Az egyik leggyorsabb algoritmus, a hosszabbik szöveg hosszával arányos időigényű. Használata akkor előnyös, ha egy eltérés felismerése sokkal több megkülönböztető információt hordoz, mint az, hogy ténylegesen hány helyen van eltérés.

def hamming_distance(s1, s2):
   diffs = 0
   for ch1, ch2 in zip(s1, s2):
       if ch1 != ch2:
             diffs += 1
   return diffs



Levenshtein távolság: szövegszerkesztési műveletek számában mért távolság, ahol a beszúrás, törlés, és elütés egyforma hibának számít. A távolság Damerau változata a két szomszédos betű felcserélését is egy hibának számolja.
Mindkét algoritmus dinamikus programozási feladatként oldható meg, így legrosszabb esetben a két szöveg hosszának szorzatával arányos időigényű. A természetes szöveghasonlóság számításának alapja. Rövid szövegek, vagy hosszabb, de kevésbé eltérő szövegek esetén alkalmazható. Illetve akkor, ha tudni kell a két szöveg egymásba alakításának pontos módját.

Az egyes szerkesztési műveletek költsége eltérően súlyozható.

def levenshtein_distance(s1,s2):
   n, m = len(s1), len(s2)
   if n > m:
       # Make sure n <= m, to use O(min(n,m)) space
       s1,s2 = s2,s1
       n,m = m,n
       
   current = range(n+1)
   for i in range(1,m+1):
       previous, current = current, [i]+[0]*n
       for j in range(1,n+1):
           add, delete = previous[j]+1, current[j-1]+1
           change = previous[j-1]
           if s1[j-1] != s2[i-1]:
               change = change + 1
           current[j] = min(add, delete, change)
           
   return current[n]



Jaro távolság: az egyező betűk számát, illetve a betűfelcseréléseket veszi figyelembe a távolság számításakor. A lényege, hogy akkor hasonlít jobban két szöveg egymáshoz, ha a rész betűsorozatai megfeleltethetőek egymásnak.
Kimondottan rövid szövegekre lett kifejlesztve, azon belül is személynevekre. Ráadásul futási időben hasonlítható a dinamikus megoldásokhoz, és a cég, valamint terméknév azonosító szerkezet is hasonló a személynevekhez.
 Hátránya, hogy matematikai értelemben véve nem ad metrikát, mert nem teljesül rá a háromszög egyenlőtlenség. Tehát azok az osztályozók, amelyek a távolság eme tulajdonságát használják ki, félreosztályozhatnak.

Az algoritmusnak létezik egy Winkler által definiált továbbfejlesztése, amelyik azon alapul, hogy a szavak elején és végén a betűsorrend helyessége sokkal fontosabb az azonosításkor, mint a közepén. Így a közepén történő különbségeket kisebb súllyal veszi figyelembe.

Az algoritmusnak létezik Java nyelvű szabad implementációja is. A jaro távolság képletében az s1 és s2 a két szöveg hosszát jelöli, az m a megegyező betűk számát, a t pedig a felcserélt betűk számát. 

Ratio hasonlóság: már nem is távolság mérték, hanem egyből hasonlóság. A python difflib csomagjában található SequenceMatcher osztály megvalósítása egy közelítő Leveshntein-féle távolság alapján számolja, míg az algoritmusban alkalmazott változat ennél kicsit nagyobb értékeket ad, hiszen a minimális szövegtávolságra épül.
Ha nincs szükség a minimális szerkesztési távolság meghatározásához, akkor a difflib modul eljárásainak implementációi is használhatóak.
Sőt az ottani megvalósításban gyors-rátát és villám-gyors-rátát is számíttathatunk, melyek a hasonlóságnak egyfajta felső korlátjait adják meg. 


A dekrementális módszerek lényege, hogy az egyes osztályokat csak azután alakítjuk ki, miután már az összes kiemelés párra ismerjük a távolságokat, és ezek alapján jelöljük ki az egymáshoz közeli csomósodásokat, és azok összevonhatóságát.
Ilyenkor egy-egy új elem hozzávétele esetén az osztályok, illetve az azokba történő besorolás jelentősen átalakulhat. Ezért ezek az algoritmusok a távolságok újraszámítása miatt vagy jelentős (négyzetes) időigényűek, vagy ezek tárolása esetén hasonló mértékben tárigényesek.
Akkor érdemes őket alkalmazni, ha az osztályhoz rendelendő új elemek nagyobb adagokban, és nem egyesével érkeznek.
A módszert pontosítani az új elemhez közeli osztályok feldolgozásának sorrendjével és a távolságok újraszámításának hatékonyságával lehet.



https://github.com/klajosw/python/blob/master/kl_python_alapok2.ipynb



mport string

def cleanword(word):
    """
      >>> cleanword('what?')
      'what'
      >>> cleanword('"now!"')
      'now'
      >>> cleanword('?,;(.-here=@&!)<{')
      'here'
      >>> cleanword('?+="word!,@$()"')
      'word'
    """
    word = word.lstrip('\'"?!,;:.+-_=@#$%&*()[]{}/\\<>\n~`')
    return word.rstrip('\'"?!,;:.+-_=@#$%&*()[]{}/\\<>\n~`')


def has_dashdash(s):
    """
      >>> has_dashdash('distance--but')
      True
      >>> has_dashdash('several')
      False
      >>> has_dashdash('critters')
      False
      >>> has_dashdash('spoke--fancy')
      True
    """
    return '--' in s


def extract_words(s):
    """
      >>> extract_words('Now is the time!  "Now", is the time? Yes, now.')
      ['now', 'is', 'the', 'time', 'now', 'is', 'the', 'time', 'yes', 'now']
      >>> extract_words('she tried to curtsey as she spoke--fancy')
      ['she', 'tried', 'to', 'curtsey', 'as', 'she', 'spoke', 'fancy']
    """
    s = s.replace('--', ' ')
    words = s.split()
    for i, word in enumerate(words):
        words[i] = cleanword(word).lower()
    return words


def wordcount(word, wordlist):
    """
      >>> wordcount('now', ['now', 'is', 'time', 'is', 'now', 'is', 'is'])
      ['now', 2]
      >>> wordcount('is', ['now', 'is', 'time', 'is', 'now', 'is', 'the', 'is'])
      ['is', 4]
      >>> wordcount('time', ['now', 'is', 'time', 'is', 'now', 'is', 'is'])
      ['time', 1]
      >>> wordcount('frog', ['now', 'is', 'time', 'is', 'now', 'is', 'is'])
      ['frog', 0]
    """
    return [word, wordlist.count(word),  [i for i,x in enumerate(wordlist) if x == word]]


def wordset(wordlist):
    """
      >>> wordset(['now', 'is', 'time', 'is', 'now', 'is', 'is'])
      ['is', 'now', 'time']
      >>> wordset(['I', 'a', 'a', 'is', 'a', 'is', 'I', 'am'])
      ['I', 'a', 'am', 'is']
      >>> wordset(['or', 'a', 'am', 'is', 'are', 'be', 'but', 'am'])
      ['a', 'am', 'are', 'be', 'but', 'is', 'or']
    """
    newlist = wordlist[:]
    newlist.sort()
    uniquewords = []
    for word in newlist:
        if word not in uniquewords:
            uniquewords.append(word)
    return uniquewords


def longestword(wordset):
    """
      >>> longestword(['a', 'apple', 'pear', 'grape'])
      5
      >>> longestword(['a', 'am', 'I', 'be'])
      2
      >>> longestword(['this', 'that', 'supercalifragilisticexpialidocious'])
      34
    """
   
    
infile = open('c:/aa/alice_in_wonderland.txt', 'r')
text = infile.read()
infile.close()

wordlist = extract_words(text)
words = wordset(wordlist)

wordcounts = []

for word in words:
    wordcounts.append(wordcount(word, wordlist))


outfile = open('c:/aa/alice_in_wonderland_number.txt', 'w')
outfile.write("%-18s%s\n" % ("Word", "Count"))
outfile.write("=======================\n")

for word in wordcounts:
                if word[0] and word[0][0] in string.ascii_letters:
             outfile.write("%-18s %d -> %30s \n" % (word[0], word[1], word[2]))
               
                  
#                print(",".join(word).tostring()  + '\n')
#           outfile.write("%-18s %d\n" (word[0], word[1]))
          # outfile.write("%-18s %d s% \n" (word[0], word[1],",".join(word[2])))
                   ##outfile.write("%-18s  \n" -18s% ())

outfile.close()














MS oktatások

Kicsit fejlesztettem és teszteltem magamat. https://docs.microsoft.com/hu-hu/ Érdemes végig csinálni, vagy legalább kipróbálni. ...