Michał Stanek - Ruby on Rails i inne ...

Szablony dokumentów dla metodyki Rational Unified Process (RUP)

2009-10-25T19:32:00.000+01:00

Model biznesowy

Software Architecture Document

Wizja systemu

Opis Use Casa

Słownik biznesowy

Słownik systemowy

Raport spotkania projektowego

ForceSeat GT - Film Promocyjny

2009-10-24T22:35:00.001+02:00

ForceSeat GT - 3 DoF Hydraulic Motion Simulator officially announce

2009-10-21T19:37:00.006+02:00

I am pleased to announce that the first model of the hydraulic simulator was shown to a wider audience

SVN w Eclipse 3.4.2

2009-06-08T15:32:00.002+02:00

Wbrew pozorom integracja pluginu SVN w eclipsie zabiera chwilę czasu, ponieważ dostępne w sieci tutoriale dziwnym sposobem nie prowadzą do działającego rozwiązania.

Instrukcja instalacji:

Zainstalować SVN Team Provider z:
http://download.eclipse.org/technology/subversive/0.7/update-site/.

A na koniec sam plugin:
http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/

Powinno działać

Instalacja Google Chrome pod Ubuntu 9.04

2009-06-07T20:46:00.003+02:00


sudo gedit /etc/apt/sources.list

deb http://ppa.launchpad.net/chromium-daily/ppa/ubuntu jaunty main
deb-src http://ppa.launchpad.net/chromium-daily/ppa/ubuntu jaunty main 

sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 0xfbef0d696de1c72ba5a835fe5a9bf3bb4e5e17b5

sudo apt-get update
sudo apt-get install chromium-browser

Edytor LaTeXa pod Ubuntu - gEdit i LaTeX

2009-06-05T08:45:00.006+02:00

Poniżej opiszę jak zainstalować plugin LaTeXa dla gEdita, efekt końcowy można zobaczyć pod tym adresem. Instrukcja:

Zacznijmy od dodania odpowienich repozytoriów:


sudo gedit /etc/apt/sources.list.d/gedit-latex-plugin.list

W pliku tym należy wkleić poniższe wiersze:


deb http://ppa.launchpad.net/ubuntu-it-dev/ubuntu gutsy main
deb-src http://ppa.launchpad.net/ubuntu-it-dev/ubuntu gutsy main

Uaktualnienie informacji o pakietach oraz instalacja odpowiednich paczek:


sudo apt-get update
sudo apt-get install texlive-latex-recommended texlive-latex-extra texlive-fonts-extra texlive-humanities texlive-math-extra texlive-pictures
sudo apt-get install rubber gedit-latex-plugin

Kolejnym krokiem będzie uruchomienie plug-inu już w edytorze gEdit. W tym celu należy wejść do menu Edycja-Preferencje i wybrać zakładkę Wtyczki.

Install Eclipse 3.4 on Ubuntu 9.04

2009-06-03T13:08:00.001+02:00

Just follow the instructions given under the following adress:

http://zanshin.net/2009/04/25/install-eclipse-ganymede-on-ubuntu-904/

Astromenace - gra warta uwagi

2009-05-07T23:26:00.007+02:00

Dzisiaj trochę z innej beczki, ponieważ post dotyczyć będzie tematów rozrywkowych. A postanowiłem, go napisać ponieważ jak do tej pory ciekawe gry pod Linuxa to jednak rzadkość, więc jeżeli pojawia się coś interesującego myślę że warto o tym napisać.

Gra nazywa się Astromenace i jest strzelanką, w której latamy statkiem i strzelamy do wrogów. Scenariusz podobny do setek innych gier, to co wyróżnia jednak ten tytuł to bardzo starannie wykonana grafika, oraz znany zwłaszcza z gier RPG, mechanizm zdobywania doświadczenia i kupowania coraz to lepszego wyposażenia i pancerzy.

Poniżej kilka screenów z gry:

Instalacja:

Ściągamy spakowaną wersję gry ze strony producenta - link

Rozpakowujemy archiwum (np. tar jxvf amenace12.tar.bz2)

Uruchamiamy grę (./game_launcher)

Uwaga: Do prawidłowego działania gry zainstalowane musimy mieć następujące biblioteki:
libSDL, libopenal, libalut, libogg, libvorbis, libvorbisfile, libjpeg.

GIT - usunięcie plików omyłkowo dodanych do repozytorium

2009-05-04T13:13:00.004+02:00

Czasami przez omyłkę lub błąd w pliku .gitignore do repozytorium dodana może zostać dość spora liczba plików, których byśmy tam nie chcieli. W moim przypadku w repozytorium znajdowała się dość spora liczba plików *.class. Poniżej podaję prosty sposób na rozwiązanie takiego problemu:


find . -name *.class -print0 | xargs -0 `git rm`

Git - domyślny plik gitignore

2009-05-04T12:59:00.005+02:00

W przypadku kiedy pracujemy lub tworzymy wiele projektów, które wersjonujemy systemem GIT, konieczne jest wielokrotne tworzenie pliku .gitignore, w którym zawarte są reguły dotyczące plików które mają być ignorowane (ewentualnie reguły te wprowadzić można w pliku (.git/info/exclude). Jest to dość uciążliwe, na szczęście możemy zdefiniować domyślny plik gitignore dla wszystkich projektów z jakimi pracujemy. Magiczna linijka kodu która to ustawi znajduje się poniżej:


git config --global core.excludesfile ~/.gitignore

Uwagi: domyślny plik .gitignore znajduje się w katalogu domowym (nic jednak nie stoi na przeszkodze, aby umieścić go gdzie indziej)

Platforma Symylacyjna 3DoF - test sterowania za pomocą kierownicy

2009-04-27T21:24:00.003+02:00

Testy prototypu platformy hydraulicznej z trzema stopniami swobody (3 DoF)

2009-04-20T14:05:00.006+02:00

Poniżej pierwsze filmy z testów platformy hydraulicznej.

Parametry techniczne:
- Ciśnienie w układzie - regulowane nastawnym zaworem przelewowym od 5 do 20 Bar
- Skok tłoka siłownika: 13 cm
- Mikrokontroler: AVR (Atmega 8)
- Komunikacja z komputerem: USB
- Układ pomiarowy: fotooptyczny
- Ciężar urządzenia: ok 130 kg
- Wydajność pompy: 12 [l/min] (na krućcach przy siłownikach zastosowane dodatkowo dławiki)

Pluginy Ruby on Rails z których najprawdopodobniej będziesz chciał skorzystać

2009-04-17T12:53:00.029+02:00

Na RailsLab w ukazał się ciekawy artykuł, w którym znaleźć możemy zestawienie procentowe projektów wykorzystujących poszczególne wersje Ruby on Rails. Ciekwszym aspektem omawianego artykułu jest jednak zestawienie najczęściej wykorzystywanych pluginów (zrobione w oparciu o dane pochodzące z GitHuba). W pierwszej piątce znajdują się:

exception_notification

restful_authentication

will_paginate

attachment_fu

acts_as_list

W dalszej kolejności znajdują się:

hoptoad_notifer

rspec

acts_as_tree

acts_as_state_machine

auto_complete

paperclip

ssl_requirement

haml

rspec-rails

annotate_models

actice_merchant

acts_as_taggable_on_steroids

asset_packer

calendar_date_select

jrails

in_place_editing

responds_to_parent

Traffic Flow Simulation System based on Cellular Automata

2009-04-03T13:52:00.003+02:00

Below I have attached videos from my application which simulate car traffic flow. Application use Cellular Automata to simulate car movements.

Wykorzystanie Helperów w Kontrolerach i Modelu

2009-04-02T16:43:00.005+02:00

Wykorzystanie dostępnych w Railsach Helperów bezpośrednio w modelu, lub kontrolerach nie jest wspierane bezpośrednio przez środowisko. Przyczyn tego faktu należu upatrywać w chęci zapobiegania wykorzystania kodu Widoku w niższych warstwach, dzięki czemu wzrasta przejrzystość całej aplikacji. Niestety w pewnych specyficznych przypadkach bardzo pomocne staje się wykorzystanie bezpośrednio w modelu którejś z metod np. ActionView::Helpers::TextHelper.

Poniżej metoda, jaką możemy zastosować aby wywołać helpery (źródło)

Tworzymy plik np. helpery.rb w katalogu 'lib'


  def help
    Helper.instance
  end

  class Helper
    include Singleton
    include ActionView::Helpers::TextHelper
  end

Teraz wystarczy w modelu lub kontrollerze dodać nagłówek:


require 'lib/helpers'

Wywołanie metody helpera sprowadza się wówczas do wywołania:


# help.name_of_helper
help.pluralize 10, "person"

Szablon pracy magisterskiej w Latex'u

2009-03-17T09:03:00.005+01:00

Jeżeli komuś miałbym polecać narzędzie w jakim miałby pisać pracę magisterską byłby to zdecydowanie Latex. Niestety potencjalny dyplomant staje przed problemem pełnego skonfigurowania środowiska, tak aby dokument wynikowy był zgodny z normami narzuconymi na jego uczelni.

Pisząc pracę dyplomową przygotowałem szablon Latexa, uwzględniający wszystkie wymogi edytorskie jakie były narzucona na moim wydziale (Politechnika Wrocławska Wydział Informatyki i Zarządzania). Być może przyda się to komuś jako punkt startu.

Szablon pracy magisterskiej w Latexu (750 kB)

Liczba Pi z dokładnością do MILIONA liczb po przecinku

2009-03-13T17:31:00.003+01:00

3.14, a może 3.14159, chyba niewielu z nas potrzebuje z większą dokładnością przybliżać liczbę PI. A co jeśli z jakiegoś powodu potrzebna jest ZDECYDOWANIE większa dokładność, ..., sto miejsc, ..., tysiąc, ...? Teraz możliwe jest już nawet posługiwanie się liczbą Pi o dokładności do jednego MILIONA miejsc po przecinku, wystarczy tylko odwiedzić stronę:

http://3.141592653589793238462643383279502884197169399375105820974944592.com/index314.html

Inteligentne systemy w zarządzaniu ruchem drogowym

2009-03-05T12:48:00.004+01:00

Michal Stanek-Inteligentne Systemy w Zarzadzaniu Ruchem Drogowym

Publish at Scribd or explore others: Essays & Theses School Work ruch drogowy algorytmy genetyczne

Wieloagentowa Architektura Rozproszonego Systemu Przetwarzania Zadań z Dynamicznym Równoważeniem Obciążeń

2009-03-02T17:06:00.006+01:00

M Stanek-Wieloagentowa Architektura Rozproszonego Systemu Przetwarzania Zadan z Dynamicznym Rownowazeniem O...

Publish at Scribd or explore others: Research systemy wieloagentow sztuczna inteligencj

Predykcja danych w szeregach czasowych

2009-03-02T16:57:00.004+01:00

M Stanek-Predykcja Danych w Szeregach Czasowych

Publish at Scribd or explore others: School Work Draft Research sztuczna inteligencj

Predykcja danych w szeregach czasowych 1/42 Predykcja danych w szeregach czasowych na przykładzie predykcji cen akcji giełdowych spółki KGHM Polska Miedź S.A. Piotr Kupczyk (pkk@wp.pl) Michał Stanek (michal.stanek@student.pwr.wroc.pl) 13 czerwca 2005 Abstract: Prognozowanie przyszłych wartości akcji giełdowych jest marzeniem wielu osób. Artykuł przedstawia wykorzystanie hybrydowego rozwiązania bazującego na sieciach neuronowych oraz analizie statystycznej podczas predykcji danych w szeregach czasowych na przykładzie predykcji cen akcji KGHM Polska Miedź S.A. W dokumencie zostały szczegółowo omówione dwie architektury sieci neuronowych jedna bazująca na znakowej reprezentacji wartości funkcji druga bazująca na jej wartościach rzeczywistych. Na koniec omówiono rozwiązanie hybrydowe łączące Predykcja danych w szeregach czasowych moŜliwości tych sieci z predykcją opartą na funkcji regresji. Zostały omówione otrzymane wyniki oraz przedstawione moŜliwe ulepszenia. 2/42 Predykcja danych w szeregach czasowych 3/42 Spis treści: Wstęp.............................................................................................................................. 6 Dane ............................................................................................................................... 7 Predykcja ...................................................................................................................... 11 Metody predykcji ......................................................................................................... 13 Sieć neuronowa numeryczna............................................................................................ 13 Sieć neuronowa znakowa ................................................................................................. 15 Regresja ............................................................................................................................ 17 5. Eksperymenty............................................................................................................... 18 1. Badanie..................................................................................................................... 18 6. Wnioski ........................................................................................................................ 41 7. Literatura ...................................................................................................................... 42 1. 2. 3. 4. Spis tabel: Tabela 1. Dane giełdowe dla akcji spółki KGHM. .................................................................... 7 Tabela 2. Dane po preprocessingu. ............................................................................................ 7 Tabela 3. Błąd predykcji sieci liczbowej dla zbioru uczącego. ............................................... 19 Tabela 4. Liczba epok uczących sieci numerycznej dla zbioru testowego. ............................. 19 Spis rysunków: Rysunek 1. Dane giełdowe spółki KGHM................................................................................. 8 Rysunek 2. Wykres funkcji liniowej. ......................................................................................... 9 Rysunek 3. Wykres funkcji kwadratowej................................................................................... 9 Rysunek 4. Funkcja okresowa sin(x) + a ................................................................................. 10 Rysunek 5. Funkcja okresowa sin(x) + x ................................................................................ 10 Rysunek 6. Związek pomiędzy wartościami funkcji predykowanymi i rzeczywistymi. ......... 11 Rysunek 7. Idea predykcji krótko okresowej. .......................................................................... 12 Rysunek 8. Idea predykcji długo okresowej. ........................................................................... 12 Rysunek 9. Schemat blokowy hybrydy.................................................................................... 13 Rysunek 10. Schemat sieci numerycznej. ................................................................................ 14 Rysunek 11. Schemat konwersji danych dla sieci znakowej. .................................................. 15 Rysunek 12. Budowa sieci znakowej. ...................................................................................... 16 Rysunek 13. Przykład przybliŜenia funkcji wielomianem drugiego stopnia. .......................... 17 Rysunek 14. Przykład przybliŜenia funkcji wielomianem trzeciego stopnia........................... 17 Rysunek 15. Przykład przybliŜenia funkcji wielomianem czwartego stopnia......................... 17 Rysunek 16. Przykład przybliŜenia funkcji wielomianem piątego stopnia.............................. 17 Rysunek 17.Przykład przybliŜenia funkcji wielomianem szóstego stopnia. ........................... 17 Rysunek 18. Wykres zaleŜności błędu sieci numerycznej od ilości epok uczących................ 18 Rysunek 19. Wykres zaleŜności błędu sieci znakowej od ilości epok uczących. .................... 18 Rysunek 20. Funkcja linowa. ................................................................................................... 21 Rysunek 21. Predykcja na zbiorze uczącym. ........................................................................... 21 Rysunek 22. Predykcja krokowa na zbiorze testowym............................................................ 22 Rysunek 23. Predykcja ciągła na zbiorze testowym. ............................................................... 22 Predykcja danych w szeregach czasowych 4/42 Rysunek 24. Predykcja na zbiorze uczącym. ........................................................................... 22 Rysunek 25 Predykcja krokowa na zbiorze testowym............................................................. 22 Rysunek 26 Predykcja ciągła na zbiorze testowym. ................................................................ 22 Rysunek 27. Predykcja na zbiorze uczącym. ........................................................................... 23 Rysunek 28. Predykcja krokowa na zbiorze testowym............................................................ 23 Rysunek 29. Predykcja na zbiorze uczącym. ........................................................................... 23 Rysunek 30. Predykcja krokowa na zbiorze testowym............................................................ 23 Rysunek 31. Funkcja kwadratowa............................................................................................ 24 Rysunek 32. Predykcja na zbiorze uczącym. ........................................................................... 24 Rysunek 33. Predykcja krokowa na zbiorze testowym............................................................ 25 Rysunek 34. Predykcja ciągła na zbiorze testowym. ............................................................... 25 Rysunek 35. Predykcja na zbiorze uczącym. ........................................................................... 25 Rysunek 36. Predykcja krokowa na zbiorze testowym............................................................ 25 Rysunek 37. Predykcja ciągła na zbiorze testowym. ............................................................... 25 Rysunek 38. Predykcja na zbiorze uczącym. ........................................................................... 26 Rysunek 39. Predykcja krokowa na zbiorze testowym............................................................ 26 Rysunek 40. Predykcja na zbiorze uczącym. ........................................................................... 26 Rysunek 41. Predykcja krokowa na zbiorze testowym............................................................ 26 Rysunek 42. Funkcja sinusoidalna. .......................................................................................... 27 Rysunek 43. Predykcja na zbiorze uczącym. ........................................................................... 27 Rysunek 44. Predykcja krokowa na zbiorze testowym............................................................ 28 Rysunek 45. Predykcja ciągła na zbiorze testowym. ............................................................... 28 Rysunek 46. Predykcja na zbiorze uczącym. ........................................................................... 28 Rysunek 47. Predykcja krokowa na zbiorze testowym............................................................ 28 Rysunek 48. Predykcja ciągła na zbiorze testowym. ............................................................... 28 Rysunek 49. Funkcja sinusoidalno-malejąca. .......................................................................... 29 Rysunek 50. Predykcja na zbiorze uczącym. ........................................................................... 29 Rysunek 51. Predykcja krokowa na zbiorze testowym............................................................ 30 Rysunek 52. Predykcja ciągła na zbiorze testowym. ............................................................... 30 Rysunek 53. Predykcja na zbiorze uczącym. ........................................................................... 30 Rysunek 54. Predykcja krokowa na zbiorze testowym............................................................ 30 Rysunek 55. Predykcja ciągła na zbiorze testowym. ............................................................... 30 Rysunek 56. Predykcja na zbiorze uczącym. ........................................................................... 31 Rysunek 57. Predykcja krokowa na zbiorze testowym............................................................ 31 Rysunek 58. Predykcja na zbiorze uczącym. ........................................................................... 31 Rysunek 59. Predykcja krokowa na zbiorze testowym............................................................ 31 Rysunek 60. Funkcja notowań akcji firmy KGHM Polska Miedź S.A. .................................. 32 Rysunek 61. Predykcja na zbiorze uczącym. .......................Błąd! Nie zdefiniowano zakładki. Rysunek 62. Predykcja krokowa na zbiorze testowym............................................................ 33 Rysunek 63. Predykcja ciągła na zbiorze testowym. ............................................................... 33 Rysunek 64. Predykcja na zbiorze uczącym. ........................................................................... 33 Rysunek 65. Predykcja krokowa na zbiorze testowym............................................................ 34 Rysunek 66. Predykcja ciągła na zbiorze testowym. ............................................................... 34 Rysunek 67. Predykcja na zbiorze uczącym. .......................Błąd! Nie zdefiniowano zakładki. Rysunek 68. Predykcja krokowa na zbiorze testowym............................................................ 35 Rysunek 69. Predykcja ciągła na zbiorze testowym. ............................................................... 35 Rysunek 70. Predykcja na zbiorze uczącym. ........................................................................... 35 Rysunek 71. Predykcja krokowa na zbiorze testowym............................................................ 35 Rysunek 72. Predykcja na zbiorze uczącym. ........................................................................... 35 Rysunek 73. Predykcja krokowa na zbiorze testowym............................................................ 35 Predykcja danych w szeregach czasowych 5/42 Rysunek 74. Predykcja na zbiorze uczącym. ........................................................................... 35 Rysunek 75. Predykcja krokowa na zbiorze testowym, ciągły w stosunku do zbioru uczącego. .......................................................................................................................................... 37 Rysunek 76. Predykcja ciągła na zbiorze testowym, po okresie jednorocznej przerwy, w stosunku do zbioru uczącego............................................................................................ 37 Rysunek 77. Okno główne programu - widok parametrów nauki. .......................................... 38 Rysunek 78. Okno główne programu - widok parametrów predykcji ..................................... 39 Rysunek 79. Okno główne programu - widok danych wyników. ............................................ 39 Rysunek 80. Okno główne programu - widok danych predykcji............................................. 40 Predykcja danych w szeregach czasowych 6/42 1. Wstęp Dokument ten poświęcony jest zagadnieniu predykcji danych w szeregach czasowych. Na wstępie postaramy się wyjaśnić podstawowe pojęcia uŜywane zarówno w tytule jak i dalszej części niniejszej pracy. Jednym z kluczowych pojęć jest predykcja danych, polega ona na próbie przewidzenia t przyszłych wartości funkcji na podstawie n wcześniejszych wartości. Drugim bardzo waŜnym pojęciem jest szereg czasowy, który jest ciągiem następujących po sobie czasowo wartości. Szereg czasowy moŜe na przykład stanowić odczyt wskazań urządzenia pomiarowego lub zestawienie cen akcji giełdowych danej spółki na giełdzie. Predykcja cen akcji giełdowych jest niezmiernie interesująca dziedziną biorąc pod uwagę korzyści, jakie moŜe przynieść dokładne prognozowanie kolejnych wartości cenowych. Na podstawie tych prognoz moŜna podejmować decyzję czy dane akcje warto kupować w danej chwili czy teŜ moŜe lepiej je sprzedać. Im predykcja jest bardziej dokładna tym lepiej moŜna operować dysponowanymi przez nas pieniędzmi. Nic więc dziwnego, Ŝe prowadzi się wiele prac na ten temat. Niestety wiele z rozwiązań nie jest publikowanych i stanowią one jedynie część całych pakietów, których cena jest czasami niesamowicie wysoka. Predykcja moŜe być krótko lub długookresowa. Predykcja krótko okresowa dotyczy zazwyczaj predykcji kilku wartości w przód, podczas gdy predykcja długookresowa swoim zasięgiem moŜe obejmować bardzo długie okresy. Przyjmuje się, Ŝe dla predykcji krótko okresowych błąd szacowanych wartości z wartościami rzeczywistymi powinien być bardzo mały. Podczas predykcji długookresowej tolerowana jest nawet znaczna rozbieŜność na rzecz zachowania ogólnego trendu danych. W dokumencie tym opisane jest wykorzystanie sieci neuronowych oraz metod regresji w zadaniu predykcji danych. Metody te zostaną dokładnie scharakteryzowane w dalszej części tej pracy. Predykcja danych w szeregach czasowych 7/42 2. Dane Udało się uzyskać dane giełdowe spółki KGHM z lat 2001 – 2005, pobrane one zostały z serwisu www.money.pl. Wśród wartości, jakimi dysponowaliśmy były: • • • • • • Cena otwarcia Cena minimalna w ciągu dnia Cena maksymalna w ciągu dnia Cena podczas zamknięcia giełdy Procentowa zmiana w stosunku do dnia poprzedniego Ilość sprzedanych akcji w ciągu dnia (wolumen) W Tabela 1 znajduje się przykład formatu wykorzystywanych danych. Tabela 1. Dane giełdowe dla akcji spółki KGHM. Data 2005-05-27 2005-05-25 2005-05-24 2005-05-23 2005-05-20 2005-05-19 2005-05-18 2005-05-17 2005-05-16 Otw 29,10 28,60 28,60 28,70 28,90 28,90 28,30 28,90 29,00 Min 29,00 28,60 28,10 28,50 28,50 28,50 27,70 27,70 28,20 Max 29,40 29,00 28,70 29,00 29,40 29,00 28,50 28,90 29,00 Zamkn 29,40 28,90 28,60 28,60 28,60 29,00 28,40 28,10 28,60 Zmn.[%] Wolumen 1,73 1,05 0,00 0,00 -1,38 2,11 1,07 -1,75 -1,72 328848 271585 256392 231664 549326 1188384 818496 702573 207168 s Uznaliśmy, Ŝe interesująca z naszego punktu widzenia jest szczególnie wartość dotycząca ceny akcji podczas zamknięcia giełdy. Posiadane przez nas dane zostały poddane wstępnemu preprocessingowi, w którym usunęliśmy kolumny nie istotne z naszego punktu widzenia. W Tabela 2 został pokazany widok danych po tym procesie. Tabela 2. Dane po preprocessingu. Data 2005-05-27 2005-05-25 2005-05-24 2005-05-23 2005-05-20 2005-05-19 2005-05-18 2005-05-17 2005-05-16 Zamkn 29,40 28,90 28,60 28,60 28,60 29,00 28,40 29,40 28,90 Na Rysunek 1 przedstawiona jest zmiana wartości akcji w czasie. Predykcja danych w szeregach czasowych Dane giełdowe spółki KGHM 45,00 8/42 40,00 35,00 30,00 Wartość akcji [zł] 25,00 20,00 15,00 10,00 5,00 0,00 2005-05-27 2005-04-18 2005-03-07 2005-01-27 2004-12-21 2004-11-12 2004-10-04 2004-08-26 2004-07-20 2004-06-11 2004-05-04 2004-03-23 2004-02-13 2004-01-07 2003-11-25 2003-10-16 2003-09-09 2003-07-31 2003-06-24 2003-05-15 2003-04-03 2003-02-25 2003-01-17 2002-12-05 2002-10-24 2002-09-17 2002-08-08 2002-07-01 2002-05-20 2002-04-09 2001-11-20 2001-07-30 2001-04-04 2000-08-11 1999-05-25 1999-03-29 1999-01-22 1998-11-09 Data [dni] Rysunek 1. Dane giełdowe spółki KGHM. PoniewaŜ nie widać w tych danych wyraźniej zaleŜności postanowiliśmy przebadać nasze rozwiązanie równieŜ na innych danych wejściowych. Wybraliśmy do tego następujące funkcje: • • • • Funkcja liniowa y = ax+b Funkcja kwadratowa y = ax2 + bx + c Funkcja okresowa y = sin(x) + a Funkcja okresowa y = sin(x) + x PoniŜej znajdują się wykresy tych funkcji. Predykcja danych w szeregach czasowych Cena [zł] 10000 12000 14000 Cena [zł] 100 200 300 400 500 600 700 800 900 0 2000 4000 6000 8000 2003-01-27 2003-03-27 2003-05-27 2003-07-27 0 2002-04-16 2002-06-16 2002-08-16 2002-10-16 2002-12-16 Rysunek 3. Wykres funkcji kwadratowej. Funkcja kwadratowa y=ax^2+bx+c Rysunek 2. Wykres funkcji liniowej. 2003-02-16 2003-04-16 2003-06-16 2003-08-16 Data [dni] 2003-10-16 2003-12-16 2004-02-16 2004-04-16 2004-06-16 2004-08-16 2004-10-16 2004-12-16 2005-02-16 2003-09-27 Funkcja liniowa y=-ax+b 2003-11-27 2004-01-27 Data [dni] 2004-03-27 2004-05-27 2004-07-27 2004-09-27 2004-11-27 2005-01-27 2005-03-27 2005-04-16 2005-05-27 9/42 Predykcja danych w szeregach czasowych Cena [zł] 10,00 12,00 14,00 Cena [zł] 10,5 11,5 8,5 9,5 10 11 8 9 0,00 2002-04-16 2002-06-16 2002-08-16 2002-10-16 2002-12-16 2,00 4,00 6,00 8,00 2002-04-16 2002-06-16 2002-08-16 2002-10-16 2002-12-16 Rysunek 5. Funkcja okresowa sin(x) + x Rysunek 4. Funkcja okresowa sin(x) + a 2003-02-16 2003-04-16 2003-02-16 2003-04-16 2003-06-16 2003-08-16 Data [dni] 2003-10-16 2003-12-16 2004-02-16 2004-04-16 2004-06-16 2004-08-16 2004-10-16 2004-12-16 2005-02-16 2005-04-16 Funkcja okresowa y=sin(x)+a Fukncja sin(x)+x 2003-06-16 2003-08-16 Data [dni] 2003-10-16 2003-12-16 2004-02-16 2004-04-16 2004-06-16 2004-08-16 2004-10-16 2004-12-16 2005-02-16 2005-04-16 10/42 Predykcja danych w szeregach czasowych 11/42 3. Predykcja Jak wspominaliśmy juŜ we wstępie predykcja ma za zadanie oszacowanie wartości funkcji na podstawie innych jej wartości. Predykcja w szeregach czasowych bazuje na wartościach z przeszłości w celu próby oszacowania wartości w kolejnych punktach czasu. Jakość predykcji mierzy się zazwyczaj jako średnie odchylenie wartości uzyskanych w poszczególnych punktach od wartości rzeczywistych (oczekiwanych). Weźmy pod uwagę przykładową funkcję przedstawioną na Rysunek 6, oraz pewne punkty kontrolne t0, t1 oraz t2. Funkcja rzeczywista, czyli ta która próbujemy oszacować narysowana jest linią ciągłą, zaś nasze oszacowanie na wykresie narysowane jest linią przerywaną. Z rysunku łatwo moŜna zobaczyć, Ŝe znalezione oszacowanie róŜni się od funkcji jakiej szukaliśmy. Rysunek 6. Związek pomiędzy wartościami funkcji predykowanymi i rzeczywistymi. Przyjęta przez nas miara jakości predykcji wyraŜona jest wzorem (1). Błąd predykcji: n Err = Objaśnienie: ∑o i =1 z −o (1) n Err – całkowity błąd predykcji o – wartość uzyskana z predykcji oz – wartość oczekiwana n – ilość elementów predykowanego zbioru Predykcja danych w szeregach czasowych 12/42 Predykcja krótko okresowa – jest to rodzaj predykcji, który na podstawie wartości z przeszłości (okna) próbuje oszacować małą liczbę wartości w przyszłości. Podczas takiej predykcji nacisk kładziony jest na minimalizacje błędu predykcji. Podczas predykcji kaŜdej wartości wykorzystuje się dane rzeczywiste. W przypadku naszego programu byłaby to sytuacja, w której prognozuje on cenę akcji na następny dzień na podstawie wartości poprzednich. Za kaŜdym razem do programu podawane są rzeczywiste wartości cen akcji z dni poprzednich. Cena [zł] Rysunek 7. Idea predykcji krótko okresowej. Predykcja długo okresowa – to rodzaj predykcji który ma na celu prognozę trendu badanej funkcji. Nacisk kładziony jest na zachowanie ogólnego charakteru funkcji, a niŜeli dokładne przewidzenie przyszłych wartości. Predykcja taka dokonywana jest zazwyczaj poprzez przesuwanie okna danych z jednoczesnym włączaniem do szeregu uczącego przewidzianych wartości. Schemat ideowy takiego rozwiązania przedstawiony jest na Rysunek 8. Rysunek 8. Idea predykcji długo okresowej. Predykcja danych w szeregach czasowych 13/42 4. Metody predykcji W programie zostały zastosowane trzy metody predykcji. Dwie z nich wykorzystują sztuczną sieć neuronową, trzecia natomiast opiera się na metodzie regresji wielomianowej dowolnego stopnia. Rozwiązanie hybrydowe umoŜliwia wykorzystanie dowolnej kombinacji tych metod. Na Rysunek 9 przedstawiony jest ideowy schemat pracy hybrydy z włączonymi wszystkimi metodami predykcji. Rysunek 9. Schemat blokowy hybrydy. W dalszej części tego rozdziału zostanie dokładnie wyjaśnione kaŜde z tych rozwiązań. Sieć neuronowa numeryczna Jako pierwsze omówimy rozwiązanie bazujące na sieci neuronowej z propagacją wsteczną. Nazwa „sieć numeryczna” została jej nadana ze względu na sposób pracy z danymi. Sieć ta składa się przynajmniej z trzech warstw (Rysunek 10), pierwsza warstwa – wejściowa, jest odpowiedzialna za pobieranie wartości funkcji. Liczność tej warstwy odpowiada dokładnie szerokości okna danych. KaŜdy neuron pobiera wobec tego jedną wartość z okna i przekazuje go do warstwy ukrytej. Warstwa ukryta jest konfigurowalna w programie. MoŜemy określić ile neuronów będzie wchodzić w jej skład. Dodatkowo mamy równieŜ moŜliwość określenia ilości tych warstw. W literaturze podawane jest jednak najczęściej, Ŝe sieć taka powinna posiadać jedną warstwę ukrytą o liczności równej ilości neuronów w warstwie wejściowej. W naszym programie postanowiliśmy jednak sprawdzić jak zachowują się sieci z większą ilością warstw ukrytych oraz z róŜna od wejściowej liczbą neuronów w nich zawartych. Warstwa wyjściowa składa się zawsze z jednego neuronu, którego wartość na wyjściu stanowi wynik działania sieci. Predykcja danych w szeregach czasowych 14/42 Wyjście – denormalizacja wartości Warstwa wyjściowa Warstwa ukryta 1 2 3 4 5 6 7 8 Warstwa wejściowa 1 2 3 4 5 6 7 8 Wejścia do sieci – normalizacja danych Rysunek 10. Schemat sieci numerycznej. Błąd działania sieci: ilośl _ wyjsc ilosc _ wzorców Blad = Objaśnienie: ∑ (o i =0 Z − o) 2 ∑ i =1 (2) ilosc _ wyjsc Blad –błąd pracy sieci neuronowej o – wartość uzyskana na wyjściu z neuronu warstwy wyjściowej oz – wartość oczekiwana na wyjściu neuronu ilosc_wzorców – ilość wzorców danych ilosc_wyjsc – ilość wyjść sieci neuronowej Wartości dostarczane do warstwy wejściowej poddaje się normalizacji zgodnie z następującym wzorem: Normalizacja wartości wejściowej xs = Objaśnienie: xr − min max − min (3) xs – wartość podawana na wejście sieci Predykcja danych w szeregach czasowych xr – wartość rzeczywista przekazana na wejście min – minimalna wartość w zbiorze danych max – maksymalna wartość w zbiorze danych Wyjście z sieci następnie poddawane jest procesowi denormalizacji: 15/42 xs = xr ⋅ (max − min) + min Objaśnienie: xs – wartość podawana na wejście sieci xr – wartość rzeczywista przekazana na wejście min – minimalna wartość w zbiorze danych max – maksymalna wartość w zbiorze danych (4) Do uczenia sieci zastosowany jest algorytm propagacji wstecznej. KaŜdy z neuronów wchodzących w skład sieci ma dodatkowe wejście zwane biasem, które zawsze na wejściu ma podawaną wartość 1. Jako funkcja aktywacji neuronu zastosowana została funkcja unipolarna. Sieć neuronowa znakowa Sieć znakowa w naszym programie to specyficzny rodzaj sieci, która na wejściu analizuje nie wartości liczb a cyfry, z jakich one się składają. Efektem działania takiej sieci jest zatem predykcja pewnego napisu, który w szczególności będzie liczbą. Przykład konwersji liczby 2.5 na wejścia sieci znakowej został pokazany na Rysunek 11. Rysunek 11. Schemat konwersji danych dla sieci znakowej. NaleŜy zwrócić uwagę, Ŝe dla ciągu liczb 2.5; 2.51; 4.321 naleŜy ujednolicić ich zapis. W programie realizowane jest to dopisaniem tylu zer końcowych, aby długość kaŜdej liczby była taka sama. Dla naszego przykładu po takiej konwersji uzyskalibyśmy liczby (a w zasadzie napisy): 2.500 ; 2.510; 4.321 Predykcja danych w szeregach czasowych Budowa sieci znakowej jest następująca: • • • 16/42 Liczba neuronów w warstwie wejściowej – długość najdłuŜszej liczby (w postaci napisu) * 4 * szerokość okna Liczba neuronów w warstwie ukrytej – 0.5 * ilość neuronów wejściowych Liczba neuronów wyjściowych – długość najdłuŜszej liczby z danych uczących (w postaci napisu) * 4 Rysunek 12. Budowa sieci znakowej. Liczba, 4 przez która przemnaŜana jest liczba neuronów warstwy wejściowej i wyjściowej, wynika z faktu konwersji kaŜdej cyfry na postać binarną. PoniewaŜ musimy zakodować 10 cyfr oraz przecinek, potrzebnych jest naw w tym celu 11 wartości, a najbliŜsza potęgą dwójki jest 4 (liczba 16). KaŜdy neuron sieci znakowej zbudowany jest tak samo jak neuron sieci numerycznej. Błąd sieci równieŜ liczony jest ze wzoru (2). Sieć uczona jest równieŜ algorytmem BackPropagation. Zdecydowaną róŜnicą, jaka cechuje sieć znakową i sieć liczbową poza sposobem interpretacji danych wejściowych jest ilość neuronów, jaka wchodzi w ich skład. Zastosowanie sieci znakowej wynikało z paru czynników. Pierwszy z nich polegał na chęci przetestowania zastosowalności i przydatności takiego podejścia. Nigdzie w literaturze nie spotkaliśmy się z podobnym rozwiązaniem, dlatego ciekawiło nas jakie rezultaty jesteśmy w stanie osiągnąć z jego pomocą. Drugim powodem jaki przemawiał za zastosowaniem sieci znakowej był fakt jej wraŜliwości nawet na bardzo małe zmiany wartości wejściowych. Wystarczy, Ŝe weźmiemy taki przykład: Zakres danych = 100 Wartość 1 = 45.500 Wartość 2 = 49.000 Wartość 3 = 45.506 Dla sieci numerycznej wartości 1 oraz 3 są w zasadzie nierozróŜnialne, podczas gdy w sieci znakowej zmianie ulegnie wartość 3 neuronów. Regresja jest metodą, która polega na ustaleniu wzoru krzywej pewnego stopnia, w naszym przypadku jest to krzywa wielomianowa, poprzez dostrajanie jej parametrów. Dostrajanie to polega na minimalizacji średniego odchylenia krzywej aproksymującej prostą od funkcji bazowej. Wybranie stopnia wielomianu pozawala na mniejsze lub większe dopasowanie się krzywej regresji do funkcji. PoniŜej przedstawionych jest kilka przykładów, które demonstrują wpływ stopnia wielomianu na otrzymany wynik: Regresja Predykcja danych w szeregach czasowych Wartość akcji [zł] Wartość akcji [zł] 10,00 15,00 20,00 25,00 30,00 35,00 40,00 45,00 0,00 5,00 10,00 15,00 20,00 25,00 30,00 35,00 40,00 45,00 0,00 5,00 2005-05-27 2005- 05-27 Rysunek 15. Przykład przybliŜenia funkcji wielomianem czwartego stopnia. Rysunek 13. Przykład przybliŜenia funkcji wielomianem drugiego stopnia. 2005-04-19 2005-03-09 2005-02-01 2004-12-27 2004-11-19 2004-10-12 2004-09-06 2004-07-30 2004-06-24 2004-05-18 2004-04-07 2004-03-02 2005- 04-19 2005- 03-09 2005- 02-01 2004- 12-27 2004- 11-19 2004- 10-12 2004- 09-06 2004- 07-30 2004- 06-24 2004- 05-18 2004- 04-07 2004- 03-02 Rysunek 17.Przykład przybliŜenia funkcji wielomianem szóstego stopnia. Dane giełdowe spółki KGHM Dane giełdowe spółki KGHM 2004- 01-26 2003- 12-15 2003- 11-06 2003- 10-01 2003- 08-26 2003- 07-18 Data [dni] 2003- 06-11 2003- 05-06 2003- 03-26 2003- 02-18 2003- 01-13 2002- 12-02 2002- 10-22 2002- 09-16 2002- 08-08 2002- 07-02 2002- 05-22 2002- 04-12 2001- 12-14 2001- 08-22 2001- 05-16 2000- 10-13 1999- 08-25 1999- 04-26 1999- 02-15 1998- 12-02 2004-01-26 2003-12-15 2003-11-06 2003-10-01 2003-08-26 2003-07-18 Data [dni] 2003-06-11 2003-05-06 2003-03-26 2003-02-18 2003-01-13 2002-12-02 2002-10-22 2002-09-16 2002-08-08 2002-07-02 2002-05-22 2002-04-12 2001-12-14 2001-08-22 2001-05-16 2000-10-13 1999-08-25 1999-04-26 1999-02-15 1998-12-02 Wartość akcji [zł] 10,00 15,00 20,00 25,00 30,00 35,00 40,00 45,00 0,00 5,00 2005- 05-27 2005- 04-19 2005- 03-09 2005- 02-01 2004- 12-27 2004- 11-19 2004- 10-12 2004- 09-06 2004- 07-30 2004- 06-24 2004- 05-18 2004- 04-07 2004- 03-02 Dane giełdowe spółki KGHM 2004- 01-26 2003- 12-15 2003- 11-06 2003- 10-01 2003- 08-26 2003- 07-18 Data [dni] 2003- 06-11 2003- 05-06 2003- 03-26 2003- 02-18 2003- 01-13 2002- 12-02 2002- 10-22 2002- 09-16 2002- 08-08 2002- 07-02 2002- 05-22 2002- 04-12 2001- 12-14 2001- 08-22 2001- 05-16 2000- 10-13 1999- 08-25 1999- 04-26 1999- 02-15 1998- 12-02 Wartość akcji [zł] Wartość akcji [zł] 10,00 15,00 20,00 25,00 30,00 35,00 40,00 45,00 0,00 5,00 10,00 15,00 20,00 25,00 30,00 35,00 40,00 45,00 0,00 5,00 2005- 05-27 2005- 05-27 Rysunek 16. Przykład przybliŜenia funkcji wielomianem piątego stopnia. Rysunek 14. Przykład przybliŜenia funkcji wielomianem trzeciego stopnia. 2005- 04-19 2005- 03-09 2005- 02-01 2004- 12-27 2004- 11-19 2004- 10-12 2004- 09-06 2004- 07-30 2004- 06-24 2004- 05-18 2004- 04-07 2004- 03-02 2005- 04-19 2005- 03-09 2005- 02-01 2004- 12-27 2004- 11-19 2004- 10-12 2004- 09-06 2004- 07-30 2004- 06-24 2004- 05-18 2004- 04-07 2004- 03-02 Dane giełdowe spółki KGHM 2004- 01-26 2003- 12-15 2003- 11-06 2003- 10-01 2003- 08-26 2003- 07-18 Data [dni] 2003- 06-11 2003- 05-06 2003- 03-26 2003- 02-18 2003- 01-13 2002- 12-02 2002- 10-22 2002- 09-16 2002- 08-08 2002- 07-02 2002- 05-22 2002- 04-12 2001- 12-14 2001- 08-22 2001- 05-16 2000- 10-13 1999- 08-25 1999- 04-26 1999- 02-15 1998- 12-02 Dane giełdowe spółki KGHM 2004- 01-26 2003- 12-15 2003- 11-06 2003- 10-01 2003- 08-26 2003- 07-18 Data [dni] 2003- 06-11 2003- 05-06 2003- 03-26 2003- 02-18 2003- 01-13 2002- 12-02 2002- 10-22 2002- 09-16 2002- 08-08 2002- 07-02 2002- 05-22 2002- 04-12 2001- 12-14 2001- 08-22 2001- 05-16 2000- 10-13 1999- 08-25 1999- 04-26 1999- 02-15 1998- 12-02 17/42 Predykcja danych w szeregach czasowych 18/42 5. Eksperymenty 1. Badanie błędu sieci podczas procesu uczenia Pierwsze badanie miało na celu określenie zaleŜności pomiędzy wartością błędu sieci, a długością procesu uczenia. Dla sieci numerycznej zaleŜność ta została przedstawiona na Rysunek 18, a dla sieci znakowej, na Rysunek 19. Jak widać obie zaleŜności mają charakter 1/x. Uczenie sieci numerycznej 3,5 3 2,5 Wartość błędu 2 1,5 1 0,5 0 1 51 101 151 201 251 301 351 Ilość epok uczących Rysunek 18. Wykres zaleŜności błędu sieci numerycznej od ilości epok uczących. Błąd podczas uczenia sieci znakowej 5 4,5 4 3,5 Błąd sieci 3 2,5 2 1,5 1 0,5 0 1 26 51 Ilość epok 76 Rysunek 19. Wykres zaleŜności błędu sieci znakowej od ilości epok uczących. Predykcja danych w szeregach czasowych 19/42 2. Badanie wpływu parametrów uczenia na ilość epok uczących oraz błąd sieci. Badanie polegało na sprawdzeniu wpływu parametrów uczenia takich jak: maksymalny dopuszczalny błąd, współczynnik uczenia. Jak widać (Tabela 3. Błąd predykcji sieci liczbowej dla zbioru uczącego.Tabela 3 i Tabela 4) zmniejszenie wartośći dopuszczalnego błędu wpływa na polepszenie jakości otrzymywanych rozwiązań. JednakŜe związane jest to z dodatkowym kosztem obliczeniowym, wynikającym z dłuŜszego procesu uczenia. Tabela 3. Błąd predykcji sieci liczbowej dla zbioru uczącego. L.p. 1 2 3 4 5 6 7 8 9 10 Średnia: Max_bład=0,1 Wsp_uczenia=0.25 0,33944595 0,40685362 0,3211001 0,39504743 0,30614528 0,3702581 0,55567235 0,4061748 0,44178638 0,34696692 0,388945093 Max_błąd=0,1 Wsp_uczenia=0.1 0,40188 0,377126 0,435145 0,399811 0,388575 0,401558 0,39477 0,39934 0,405562 0,399018 0,400279 Max_błąd=0,01 Wsp_uczenia=0.25 0,119438 0,087539 0,139914 0,178516 0,166054 0,100523 0,119242 0,393672 0,096405 0,212274 0,161358 Tabela 4. Liczba epok uczących sieci numerycznej dla zbioru testowego. L.p. 1 2 3 4 5 6 7 8 9 10 Średnia: Max_bład=0,1 Wsp_uczenia=0.25 128 51 54 32 61 31 47 73 36 38 50,11363636 Max_błąd=0,1 Wsp_uczenia=0.1 156 67 104 87 121 131 108 130 109 104 101,5545 Max_błąd=0,01 Wsp_uczenia=0.25 443 638 723 879 505 660 848 480 742 637 595,9318 Predykcja danych w szeregach czasowych 3. Predykcja funkcji 20/42 W celu porównania działania wykorzystanych metod, poddano predykcji następujące funkcje: • funkcja liniowa • funkcja kwadratowa • funkcja sinusoidalna (sin(x) + a) • funkcja sinusoidalna połączona z funkcja liniową (sin(x) + x) • funkcja przedstawiająca notowania cen akcji firmy KGHM Polska Miedź S.A. Proces testowania polegał na wyuczeniu sieci numerycznej i znakowej na wybranym podzbiorze dziedziny funkcji, a następnie próbie predykcji wartości dla nieznanych dotąd argumentów. W kolejnych punktach przedstawione są uzyskiwane rezultaty. Predykcja danych w szeregach czasowych 4. Predykcja funkcji liniowej 21/42 Badania predykcji funkcji liniowej przedstawionej na Rys.20, miało na celu określenie zdolności systemu do wykrywania prostych zaleŜności między danymi. Rysunek 20. Funkcja linowa. Jako pierwszą zastosowaną metodę opartą na sieci numerycznej. Predykcję przeprowadzono dla dwóch wartości dopuszczalnego błędu: 1.0 i 0.01. Jak wynika z Rysunek 21 i Rysunek 24, obniŜenie progu błędu, pozwala na lepsze odwzorowanie funkcji, dla wartości wchodzących w skład zbioru uczącego. Wpływa to jednak ujemnie na zdolność uogólniania (Rysunek 22 i Rysunek 25). Akceptowalne rezultaty otrzymujemy jedynie dla predykcji krótkookresowej (krokowej). Dla predykcji długookresowej kumulacja błędu jest tak duŜa, Ŝe wartości predykowane nie zachowują nawet trendu funkcji bazowej (Rysunek 23 i Rysunek 26). Predykcja z zastosowaniem sieci numerycznej (max. błąd = 1): Rysunek 21. Predykcja na zbiorze uczącym. Predykcja danych w szeregach czasowych 22/42 Rysunek 22. Predykcja krokowa na zbiorze testowym. Rysunek 23. Predykcja ciągła na zbiorze testowym. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 0.01): Rysunek 24. Predykcja na zbiorze uczącym. Rysunek 25 Predykcja krokowa na zbiorze testowym. Rysunek 26 Predykcja ciągła na zbiorze testowym. Predykcja danych w szeregach czasowych 23/42 Drugi test został przeprowadzony na sieci znakowej (zasada działania opisana w poprzednim punkcie). Uzyskane wyniki dla duŜego błędu (powyŜej 1) nie wykazują Ŝadnej (bardzo znikomą) korelacji z funkcją bazową (Rysunek 27 i Rysunek 28). Dopiero zmniejszenie dopuszczalnego błędu pozwoliło uzyskać akceptowalne wyniki dla zbioru uczącego. JednakŜe, tak jak podejrzewaliśmy, sieć ta ma tendencję do uczenia się na pamięć, co moŜna zaobserwować na Rysunek 29 i Rysunek 30. Predykcja z zastosowaniem sieci znakowej (max. błąd = 1): Rysunek 27. Predykcja na zbiorze uczącym. Rysunek 28. Predykcja krokowa na zbiorze testowym. Predykcja z zastosowaniem sieci znakowej (max. błąd = 0.01) Rysunek 29. Predykcja na zbiorze uczącym. Rysunek 30. Predykcja krokowa na zbiorze testowym. Predykcja danych w szeregach czasowych 5. Predykcja funkcji kwadratowej 24/42 Kolejny test przeprowadzony został dla funkcji kwadratowej, przedstawionej na Rysunek 31. Badanie to ma na celu sprawdzenie zdolności uogólniania zaleŜności funkcyjnej. Badania zostały przeprowadzone zarówno dla sieci numerycznej jak i sieci znakowej. Rysunek 31. Funkcja kwadratowa. Uzyskane wyniki są porównywalne z wynikami otrzymanymi w poprzednim badaniu. Po raz kolejny swoja przewagę wykazała sieć numeryczna. Podczas testów potwierdziło się poprzednie przypuszczenie, Ŝe dla małej dopuszczalnej wartości błędu sieci, uczy się ona na pamięć. PoniŜej znajdują się otrzymane wyniki. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 1): Rysunek 32. Predykcja na zbiorze uczącym. Predykcja danych w szeregach czasowych 25/42 Rysunek 33. Predykcja krokowa na zbiorze testowym. Rysunek 34. Predykcja ciągła na zbiorze testowym. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 0.01) Rysunek 35. Predykcja na zbiorze uczącym. Rysunek 36. Predykcja krokowa na zbiorze testowym. Rysunek 37. Predykcja ciągła na zbiorze testowym. Predykcja danych w szeregach czasowych 26/42 Predykcja z zastosowaniem sieci znakowej (max. błąd = 1) Rysunek 38. Predykcja na zbiorze uczącym. Rysunek 39. Predykcja krokowa na zbiorze testowym. Predykcja z zastosowaniem sieci znakowej (max. błąd = 0.01) Rysunek 40. Predykcja na zbiorze uczącym. Rysunek 41. Predykcja krokowa na zbiorze testowym. Predykcja danych w szeregach czasowych 6. Predykcja funkcji okresowej – y=sin(x) + a 27/42 Kolejne testy przeprowadzone zostały dla funkcji okresowej w celu zbadania zdolności sieci do uczenia się schematów. Na Rysunek 42 przestawiony jest wykres funkcji bazowej. Rysunek 42. Funkcja sinusoidalna. Podczas prowadzenia badań zaobserwowaliśmy, iŜ okresowość funkcji pozwala zmniejszyć dopuszczalny błąd. W poprzednich badaniach zabieg ten dał negatywne efekty, których przejawem była nauka wzorców na pamięć. W aktualnie testowanej funkcji cecha ta jest poŜądana. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 1): Rysunek 43. Predykcja na zbiorze uczącym. Predykcja danych w szeregach czasowych 28/42 Rysunek 44. Predykcja krokowa na zbiorze testowym. Rysunek 45. Predykcja ciągła na zbiorze testowym. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 0.01): Rysunek 46. Predykcja na zbiorze uczącym. Rysunek 47. Predykcja krokowa na zbiorze testowym. Rysunek 48. Predykcja ciągła na zbiorze testowym. Predykcja danych w szeregach czasowych 7. Predykcja funkcji okresowej – y=sin(x) + x 29/42 W celu zbadania zdolności uogólniania zaleŜności funkcyjnych przy jednoczesnym wykorzystaniu faktu okresowości funkcji, badaniu poddaliśmy funkcję y=sin(x)+x. Wykres funkcji znajduje się na Rysunek 49. Rysunek 49. Funkcja sinusoidalno-malejąca. Jak wykazują przeprowadzone badania sieć numeryczna z dobrym rezultatem potrafiła odwzorować trend rozpatrywanej funkcji. Wysoka dokładność predykcji została uzyskana nie tylko na wzorcach uczących, ale równieŜ na zbiorze testowym (Rysunek 54). Wyniki predykcji długookresowej (ciągłej) pozostają nadal niezadowalające (Rysunek 52 i Rysunek 55). Predykcja z zastosowaniem sieci numerycznej (max. błąd = 1): Rysunek 50. Predykcja na zbiorze uczącym. Predykcja danych w szeregach czasowych 30/42 Rysunek 51. Predykcja krokowa na zbiorze testowym. Rysunek 52. Predykcja ciągła na zbiorze testowym. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 0.01): Rysunek 53. Predykcja na zbiorze uczącym. Rysunek 54. Predykcja krokowa na zbiorze testowym. Rysunek 55. Predykcja ciągła na zbiorze testowym. Predykcja danych w szeregach czasowych Predykcja z zastosowaniem sieci znakowej (max. błąd = 1): 31/42 Rysunek 56. Predykcja na zbiorze uczącym. Rysunek 57. Predykcja krokowa na zbiorze testowym. Predykcja z zastosowaniem sieci znakowej (max. błąd = 0.01): Rysunek 58. Predykcja na zbiorze uczącym. Rysunek 59. Predykcja krokowa na zbiorze testowym. Predykcja danych w szeregach czasowych 32/42 8. Predykcja danych giełdowych na przykładzie notowań akcji firmy KGHM Polska Miedź S.A. Najbardziej istotnym testem z punktu widzenia projektu było badanie zaproponowanego rozwiązania na danych rzeczywistych. Wstępna analiza ciągu uczącego nie pozwalała nam zakładać, Ŝe istnieją w nim jakiekolwiek zaleŜności funkcyjne (Rysunek 60). Rysunek 60. Funkcja notowań akcji firmy KGHM Polska Miedź S.A. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 1): Rysunek 61. Predykcja na zbiorze uczącym Predykcja danych w szeregach czasowych 33/42 Rysunek 62. Predykcja krokowa na zbiorze testowym. Rysunek 63. Predykcja ciągła na zbiorze testowym. Dla duŜej wartości dopuszczalnego błędu, sieć numeryczna nie odwzorowuje funkcji bazowej. Jest to związane z faktem bardzo małej róŜnicy pomiędzy kolejnymi wartościami w ciągu uczącym (Rysunek 61, Rysunek 62 i Rysunek 63). Predykcja z zastosowaniem sieci numerycznej (max. błąd = 0.01): Rysunek 64. Predykcja na zbiorze uczącym. Predykcja danych w szeregach czasowych 34/42 Rysunek 65. Predykcja krokowa na zbiorze testowym Rysunek 66. Predykcja ciągła na zbiorze testowym. Przy obniŜeniu wartości dopuszczalnego błędu, uzyskane rezultaty na ciągu testowym wykazują niesamowite zdolności predykcji danych. Sieć potrafiła poprawnie predykować wartości dla 4-miesięcznego okresu następującego po ciągu uczącym. Niemniej jednak zdolność do predykcji długoterminowej nie uległa znacznej poprawie. Okres predykcji w tym przypadku nie przekracza nawet tygodnia. Predykcja z zastosowaniem sieci numerycznej (max. błąd = 0.001): Rysunek 67. Predykcja na zbiorze uczącym Predykcja danych w szeregach czasowych 35/42 Rysunek 68. Predykcja krokowa na zbiorze testowym. Rysunek 69. Predykcja ciągła na zbiorze testowym. Predykcja z zastosowaniem sieci znakowej (max. błąd = 1): Rysunek 70. Predykcja na zbiorze uczącym. Rysunek 71. Predykcja krokowa na zbiorze testowym. Predykcja z zastosowaniem sieci znakowej (max. błąd = 0.01) Rysunek 72. Predykcja na zbiorze uczącym. Rysunek 73. Predykcja krokowa na zbiorze testowym. Predykcja danych w szeregach czasowych Predykcja z zastosowaniem sieci znakowej (max. błąd = 0.001) 36/42 Rysunek 74. Predykcja na zbiorze uczącym. Rysunek 75. Predykcja krokowa na zbiorze testowym. Zaskakującym jest fakt, iŜ sieć znakowa wykazuje zdolność do wiernego odwzorowywania tak złoŜonej funkcji. Wyniki uzyskane w tej części badań są dla nie duŜo lepsze, niŜ w poprzednich testach. W pewnych sytuacjach jest ona lepsza niŜ sieć numeryczna. Wytłumaczyć to moŜna faktem, iŜ w ciągu uczącym róŜnice pomiędzy kolejnymi elementami są bardzo małe. Predykcja z zastosowaniem sieci numerycznej i sieci znakowej (max. błąd = 0.01): Rysunek 76. Predykcja na zbiorze uczącym. Predykcja danych w szeregach czasowych 37/42 Rysunek 77. Predykcja krokowa na zbiorze testowym, ciągłym w stosunku do zbioru uczącego. Rysunek 78. Predykcja ciągła na zbiorze testowym, po okresie jednorocznej przerwy, w stosunku do zbioru uczącego. Ostatnie badanie polegało na sprawdzeniu jakości predykcji dla danych testowych, pochodzących z następujących po sobie lat. Jak moŜna zauwaŜyć dokładność działania sieci maleje wraz z Predykcja danych w szeregach czasowych 38/42 6. Opis programu PoniŜsze rysunki przedstawiają interfejs programu oraz jego podstawowe funkcje. Okno z wykresem wyników Wybór metod predykcji Otrzymane krzywe predykcji Parametry sieci numerycznej Parametry regresji wielomianowej Parametry nauki sieci neuronowych Parametry zbiorów uczących Rozpoczęcie nauki Rysunek 79. Okno główne programu - widok parametrów nauki. Predykcja danych w szeregach czasowych 39/42 Parametry dotyczące zakresu predykcji Parametry dotyczące typu predykcji Rozpoczęcie predykcji Uzyskane wartości z predykcji Rysunek 80. Okno główne programu - widok parametrów predykcji Dane kontrolne gromadzone w procesie nauki oraz predykcji Rysunek 81. Okno główne programu - widok danych wyników. Predykcja danych w szeregach czasowych 40/42 Wartość predykcji sieci znakowej Wartość predykcji dla metody regresji Wartość rzeczywista funkcji Wartość predykcji sieci numerycznej Rysunek 82. Okno główne programu - widok danych predykcji. Predykcja danych w szeregach czasowych 41/42 7. Wnioski Projekt dał nam moŜliwość zgłębienia wiedzy na temat predykcji i aproksymacji danych. Postawiony przed nami rzeczywisty problem, pozwolił nam zastosować własne rozwiązanie w postaci sieci znakowej. Podejście to nie było nigdzie opisane, dlatego z niecierpliwością oczekiwaliśmy na pierwsze wyniki. W celu zwiększenia efektywności tej metody, postanowiliśmy wspomóc ją innymi rozwiązaniami. Tworząc tym samym system hybrydowy. Nie ogranicza to w Ŝaden sposób naszych moŜliwości związanych z konfiguracją poszczególnych modułów. W celu oceny otrzymanego rozwiązania, przeprowadzone zostały testy na wybranych funkcjach o róŜnych charakterystykach. W dokumencie zamieszczone zostały wyniki przeprowadzonych badań. Sieć numeryczna w znakomitej większości przypadków wykazywała swoją przewagę nad innymi podejściami. Na jej korzyść przemawiają równieŜ: prostota oraz powszechnie znany algorytm uczenia. Zaproponowana przez nas sieć znakowa nie radziła sobie dobrze z funkcjami testowymi. Jednak dla funkcji rzeczywistej (notowań akcji na giełdzie) spisywała się ona porównywalnie lub w nielicznych przypadkach nawet lepiej niŜ sieć numeryczna. Efekt ten uzyskiwany był jednak tylko na krótkich przedziałach czasowych, nieznacznie oddalonych od zbioru uczącego. W projekcie uŜytkownik ma równieŜ moŜliwość wykorzystania metod statystycznych, jaką jest regresja wielomianowa. Rozwiązanie nasze cechuje bardzo dobra zdolność predykcji krótkookresowej, która moŜe być przydatna w rzeczywistych zastosowaniach, na przykład podczas gry na giełdzie. Wyniki predykcji długoterminowej są niezadowalające, czego moŜna się było spodziewać ze względu na kumulację błędów predykcji krótkookresowej, co w skali dłuŜszego okresu czasu odbiegało znacznie od wartości rzeczywistych. Projekt ten stanowił dla nas wyzwanie i pozwolił nam zgłębić nasza wiedzę w tej dziedzinie. Predykcja danych w szeregach czasowych 42/42 Literatura Benjamin W. Wah, Minglun Qian „Constrained Formulations and Algorithms for Stock-Price Predictions Using Recurrent FIR Neural Networks” G. E. P. Box, G. M. Jenkins „Time Series Analysis: Forecasting and Control” Józef Kalisz, Ryszard Pełka, Ryszard Szplet „Problemy projektowe w precyzyjnej metrologii odcinków czasu” Rayid Ghani, Hillery Simmons „Predicting the End-Price of Online Auctions” Rick Martinelli „Market data prediction with adaptive kalman filter” Jeffrey K. MacKie-Mason Anna Osepayshvili Daniel M. Reeves Michael P. Wellman „Price Prediction Strategies for Market-Based Scheduling” Ivakhnenko, A.G. „Recent Developments of Self-Organising Modeling in Prediction and Analysis of Stock Market” Foster „Commodities Futures Price Prediction An Artificial Intelligence Approach” (presentation) Sven F. „Crone Bussiness Forecasting with Artificial Neural Networks” (presentation)

ADAPTACYJNY SYSTEM SYGNALIZACJI ŚWIETLNEJ OPARTY NA ALGORYTMIE GENETYCZNYM

2009-02-27T07:58:00.002+01:00

ADAPTACYJNY SYSTEM SYGNALIZACJI ŚWIETLNEJ OPARTY NA ALGORYTMIE GENETYCZNYM

Publish at Scribd or explore others: Math & Engineering Research skrzyżowanie metody symulacji ruc

Nowoczesne metody mikrosymulacji ruchu drogowego z wykorzystaniem automatów komórkowych

2009-02-27T07:54:00.004+01:00

Nowoczesne metody mikrosymulacji ruchu drogowego z wykorzystaniem automatów komórkowych

Publish at Scribd or explore others: Math & Engineering Research simulation cellular

Metody predykcji w szeregach czasowych

2009-02-27T06:05:00.004+01:00

"Metody predykcji w szeregach czasowych, na przykładzie predykcji cen akcji giełdowych spółki KGHM Polska Miedz S. A." referat wygłoszony na Konferencji Naukowej Studentów w 2006 roku.

Artykuł przedstawia wykorzystanie rozwiązania bazującego na sieciach neuronowych podczas predykcji danych w szeregach czasowych na przykładzie zarówno predykcji krótko jak i długo okresowej cen akcji spółki KGHM Polska Miedź S.A. Dokument szczegółowo omawia dwie architektury sieci neuronowych, jedna bazująca na znakowej reprezentacji, druga na wartościach rzeczywistych. Omówione zostały otrzymane wyniki oraz moŜliwości ulepszenia za pomocą rozwiązania hybrydowego wykorzystującego wyniki działania obu sieci połączone z analizą statystyczną.

Dokument PDF - Metody predykcji w szeregach czasowych, na przykładzie predykcji cen akcji giełdowych spółki KGHM Polska Miedz S. A. (167 kB)

Sztuczna Inteligencja - Systemy Hybrydowe

2009-02-18T17:47:00.006+01:00

Praca ta stanowi wprowadzenie w zagadnienie systemów hybrydowych (inteligentnych systemów hybrydowych). W dokumencie zawarte są podstawowe informacje dotyczące wyjaśnienia pojęć, przeglądu najczęściej wykorzystywanych metod sztucznej inteligencji oraz charakterystyki ich zalet i wad. Druga część pracy skupia się już na bardziej szczegółowych aspektach zagadnienia. Wyjaśnione w niej zostały powody oraz cele stosowania systemów hybrydowych, proponowane w literaturze architektury oraz modele komunikacji. Końcową część pracy stanowi analiza kierunków rozwoju.

Systemy Hybrydowe - Prezentacja (965 kB)

Michal Stanek-Systemy Hybrydowe

Publish at Scribd or explore others: Homework School Work systemy hybrydowe sztuczna inteligencj

Systemy Hybrydowe Wprowadzenie Michał Stanek (mikol@e-informatyka.pl) 21 stycznia 2005 Streszczenie Praca ta stanowi wprowadzenie w zagadnienie systemów hybrydowych (inteligentnych systemów hybrydowych). W dokumencie zawarte są podstawowe informacje dotyczące wyjaśnienia pojęć, przeglądu najczęściej wykorzystywanych metod sztucznej inteligencji oraz charakterystyki ich zalet i wad. Druga część pracy skupia się już na bardziej szczegółowych aspektach zagadnienia. Wyjaśnione w niej zostały powody oraz cele stosowania systemów hybrydowych, proponowane w literaturze architektury oraz modele komunikacji. Końcową część pracy stanowi analiza kierunków rozwoju. 1 SPIS TREŚCI 2 Spis treści 1 Wstęp 2 Metody sztucznej inteligencji 2.1 Krótki rys historyczny . . . . . . . . . . . . . 2.2 Przegląd metod sztucznej inteligencji . . . . . 2.2.1 Systemy eskpertowe . . . . . . . . . . 2.2.2 Sieci neuronowe . . . . . . . . . . . . . 2.2.3 Algorytmy genetyczne . . . . . . . . . 2.2.4 Logika rozmyta . . . . . . . . . . . . . 2.3 Ocena użyteczności poszczególnych rozwiązań 3 Systemy hybrydowe 3.1 Cele systemu hybrydowego . . . . . . . . . . 3.2 Architektury budowy systemów hybrydowych 3.2.1 Systemy niezależne . . . . . . . . . . . 3.2.2 Systemy transformujące . . . . . . . . 3.2.3 Systemy luźno związane . . . . . . . . 3.2.4 Systemy zintegorwane . . . . . . . . . 3.2.5 Systemy w pełni zintegrowane . . . . . 3.3 Modele pracy systemu hybrydowego . . . . . 3.4 Przykładowy system hybrydowy . . . . . . . 3.5 Kierunki rozwoju systemów hybrydowych . . 4 5 5 6 6 7 8 10 10 12 12 14 14 14 15 15 15 16 17 18 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Spis rysunków 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Kroki milowe rozwoju sztucznej inteligencji . . . . . . . . . . . . Reprezentacja ideowa systemu ekspertowego . . . . . . . . . . . . Model neuronu oraz sieci neuronowej . . . . . . . . . . . . . . . . Przykład klasteryzacji danych . . . . . . . . . . . . . . . . . . . . Schemat procesu działania algorytmu genetycznego . . . . . . . . Przykładowa reprezentacja zbiorów za pomocą logiki rozmytej . . Właściwości różnych metod sztucznej inteligencji . . . . . . . . . Możliwe elementy systemu hybrydowego . . . . . . . . . . . . . . Model systemu niezależnego . . . . . . . . . . . . . . . . . . . . . Model systemu transformującego . . . . . . . . . . . . . . . . . . Model systemu luźno powiązanego . . . . . . . . . . . . . . . . . Model systemu zintegrowanego . . . . . . . . . . . . . . . . . . . Model systemu w pełni zintegrowanego . . . . . . . . . . . . . . . Model przetwarzania w systemach hybrydowych . . . . . . . . . . Model ideowy połączenia Systemu ekspertowego z siecią neuronową Ilość prac naukowych na temat systemów hybrydowych . . . . . 5 6 8 8 9 10 11 13 14 14 15 16 16 17 18 19 SPIS RYSUNKÓW 3 17 Model agenta w systemie wieloagentowym . . . . . . . . . . . . . 19 1 WSTĘP 4 1 Wstęp Wydaje mi się, że wprowadzenie do systemów hybrydowych powinienem rozpocząć od wyjaśnienia samej nazwy, ponieważ dla osób niezaznajomionych z zagadnieniem, może wydawać się dziwna i niezrozumiała, a przez to mylnie interpretowana. Według jednej z deﬁnicji słownikowych system jest układem elementów o określonej strukturze, będący uporządkowaną logicznie całością. Hybryda, to natomiast mieszaniec powstały ze skrzyżowania dwóch różnych gatunków, ras, odmian, dziwoląg łączący cechy różnych osobników. Idea systemu hybrydowego bazuje wobec tego na integracji wielu dostępnych technik, metod, narzędzi w jednej spójnej i określonej strukturze stanowiącej logicznie uporządkowaną całość (wspólnie dążącą do osiągnięcia celu). Nasuwa się wobec tego pytanie, po co łączy się wiele różnych rozwiązań? Najogólniej można powiedzieć, że w celu osiągnięcia bardziej zadawalającego efektu niż przy wykorzystaniu każdej z tych technik osobno. Inteligentne systemy hybrydowe (Intelligent Hybrid Systems) starają się integrować odmienne techniki sztucznej inteligencji (logika rozmyta, sieci neuronowe, obliczenia ewolucyjne, metody probabilistyczne, maszynowe uczenie, systemy ekspertowe, itd. . . ). Fundamentem powstawania takich rozwiązań jest stwierdzenie, że metody te między sobą są komplementarne. W praktyce oznacza to, że metody te wzajemnie się uzupełniają, wady jednej są kompensowane zaletami innej. Istnieje wiele możliwych kombinacji wśród systemów symbolicznych i metod tak zwanej miękkiej sztucznej inteligencji (soft-computing) 1 , oraz wiele możliwych sposobów ich łączenia. Dla przykładu sieci neuronowe mogą być łączone z logiką rozmytą, wnioskowaniem na podstawie przykładów, algorytmami genetycznymi. W ostatnich latach, bardzo gwałtowny wzrost zapotrzebowania na wyraﬁnowane i złożone rozwiązania z dziedziny inteligentnych systemów informatycznych sprawia, że osiągnięcie pełnego sukcesu nie jest możliwe bez wykorzystania możliwości, jakie oferują nam systemy hybrydowe. Reprezentacja i manipulacja, przy pomocy komputerów, dużymi ilościami wiedzy oraz zapewnienie ich integralności, spójności i efektywności wykorzystania jest jednym z kluczowych nurtów badań w dziedzinie szeroko pojętej sztucznej inteligencji. Należy zdawać sobie sprawę z tego, że przyjęty przez nas format przechowywania i reprezentacji wiedzy powinien być w stanie poradzić sobie z pewnymi oczywistymi problemami. Niedokładność i niekompletność zgromadzonej wiedzy to jeden z nich. Różne sposoby przechowywania tejże wiedzy (np. sieci neuronowe, logika rozmyta, systemy ekspertowe) posiadają specyﬁczne własności radzenia sobie z danymi niepewnymi, nieprecyzyjnymi albo nawet nieprawidłowymi. Pewne metody lepiej nadają się do przechowywania danych numerycznych, jeszcze inne sprawdzają się lepiej, kiedy pragniemy operować na danych w postaci symbolicznej. Nie ma zadowalającego uniwersalnego rozwiązania, pozwalającego radzić sobie z wszystkimi problemami związanymi z reprezentacją wiedzy. 1 Pierwszy raz użył tego terminu Lotﬁ A. Zadeh 1995 2 METODY SZTUCZNEJ INTELIGENCJI 5 2 2.1 Metody sztucznej inteligencji Krótki rys historyczny Podobnie jak wiele innych, sztuczna inteligencja jest dziedziną nauki, która rozwija się w bardzo prężny sposób. W stosunkowo krótkiej historii, bo zaledwie 60 letniej, zaproponowano wiele koncepcji, które w znaczącym stopniu przyczyniły się do rozwoju, nie tylko jej, ale również wielu innych dziedzin w tym np. teorii sterowania i podejmowania decyzji. Pewne kroki milowe rozwoju AI (Artiﬁcial Intelligence) prezentuje rysunek 1. Wiele proponowanych teorii inspirowanych było przez naturę. Podczas gdy jedne próbowały ją naśladować (systemy ekspertowe, wnioskowanie na podstawie przykładów, logika rozmyta) inne ją kopiowały (sieci neuronowe, algorytmy genetyczne). Bardzo dużo danych wdrożeń systemów sztucznej inteligencji, projektowanych jako systemy ekspertowe, miało miejsce na przełomie lat 1970 1980 (MYCIN, DENDRAL, PROSPECTOR). Systemy te zostały tak oto zdeﬁniowane przez prof. Feigenbaum’a: ”inteligentne programy komputerowe wykorzystujące wiedzę oraz mechanizm wnioskowania w celu rozwiązania problemów, które są na tyle skomplikowane, że celem ich rozwiązania wymagają szczegółowej ekspertyzy wykonanej przez człowieka”. Każde z rozwiązań posiadało jednak pewne braki i ograniczenia. Problemem systemów ekspertowych była między innymi akwizycja wiedzy. Nowe rozwiązania, były odpowiedzią na wady poprzednich. Nowe koncepcje wprowadzały nowe możliwości, ale jednocześnie nowe ograniczenia. W pewnym momencie stało się oczywiste, że pewne metody da się, a nawet trzeba ze sobą łączyć, aby móc z ich pomocą rozwiązać problemy, które wcześniej były nierozwiązywalne (przy wykorzystaniu tylko jednej). W ten sposób postało pojęcie i rozpoczęły się badania nad systemami hybrydowymi. Rysunek 1: Kroki milowe rozwoju sztucznej inteligencji 2 METODY SZTUCZNEJ INTELIGENCJI 6 2.2 2.2.1 Przegląd metod sztucznej inteligencji Systemy eskpertowe Tak jak zostało to przedstawione w poprzednim punkcie idea systemu ekspertowego zainspirowana była sposobem, w jaki ludzie (eksperci w danej dziedzinie) rozwiązują zagadnienia i na podstawie pewnych przesłanek dochodzą do konkluzji (wniosków). Typowa budowa systemu ekspertowego została przedstawiona na rysunku 2. Poszczególne bloki odpowiadają za inne funkcje, bloki przedstawione kolorem jasnoszarym prezentują właściwą część systemu ekspertowego: • Baza wiedzy - stanowi bazę faktów, jaką dysponuje system. Baza ta budowana jest na podstawie danych pozyskanych od ekspertów dziedzinowych, a przekazuje ją do systemu inżynier wiedzy. • Blok rozumowania (mechanizm wnioskowania) jest to najważniejszy składnik systemu ekspertowego, jego zadaniem jest wyciąganie wniosków z przesłanek i pytań wprowadzanych przez użytkownika i generowanie odpowiedzi. • Mechanizmu wyjaśniający - umożliwia wyjaśnienie, na życzenie użytkownika, dlaczego system udzielił takiej, a nie innej odpowiedzi, albo dlaczego system zadał użytkownikowi określone pytanie. Ekstrakcją wiedzy od ekspertów zajmują się na ogół inżynierowie wiedzy. Jest to zwykle długi i żmudny proces, ponieważ wiedza stosowana przez ludzkich ekspertów jest zwykle wiedzą praktyczną i intuicyjną. Rysunek 2: Reprezentacja ideowa systemu ekspertowego 2 METODY SZTUCZNEJ INTELIGENCJI 7 Początkowo systemy ekspertowe były podatne na problemy związane z akwizycją (pozyskiwaniem wiedzy) i wnioskowaniem z niepewnością. W gruncie rzeczy problem transferu wiedzy ludzkiej do systemu ekspertowego jest kluczowy i nazywany jest w literaturze ”‘wąskim gardłem akwizycji wiedzy”’ (knowledge acquisition bottleneck ) [Giarratano98]. Jest to oczywiste o ile zrozumie się jak ciężkim i długim procesem jest przekazanie posiadanej przez eksperta wiedzy. Często wiedza ta jest rutynowa, bądź też intuicyjna, a sam ekspert nie zdaje sobie sprawy z jej posiadania. Drugim problemem systemów ekspertowych jest przekazywanie wiedzy nieścisłej, niepełnej i przybliżonej. Systemy ekspertowe wykorzystywane są m.in. w zagadnieniach: • diagnozowania, • przewidywania, • interpretacji, • planowania, • kontroli. 2.2.2 Sieci neuronowe Idea sieci neuronowych zainspirowana została modelem funkcjonowania mózgu człowieka. Sieć neuronowa składa się z neuronów oraz połączeń miedzyneronowych (rysunek 3). Sieć uczy się zależności, które występują między danymi, można powiedzieć, że sama ekstrahuje reguły, które w systemie ekspertowym trzeba było przekazać ręcznie. Informacje na temat tych właśnie reguł kodowane są w połączeniach miedzyneuronowych, a dokładniej w wagach wejść każdego neuronu. W odróżnieniu od systemu ekspertowego, typowa sieć neuronowa pracuje na danych numerycznych, a nie symbolicznych. Problemem staje się proces wyjaśnienia, dlaczego sieć odpowiedziała tak a nie inaczej. Wiedza nie jest zapisana w czytelny dla człowieka sposób. Można powiedzieć, że sieć działa i generuje odpowiedzi, ale tak naprawdę nie wiemy, dlaczego takie a nie inne. Jest to bardzo poważne ograniczenie, ponieważ czasami musimy wiedzieć, na jakiej podstawie została podjęta pewna decyzja. Dużą zaletą sieci neuronowych jest fakt automatycznego wydobywania wiedzy z przykładów uczących (tutaj pojawia się problem doboru odpowiednich przykładów uczących i testujących). Oprócz sieci neuronowych uczonych z nauczycielem istnieją również sieci, które uczą się bez nadzoru (rysunek 3). Wynikiem ich nauki jest rozpoznanie zależności, jakie występują miedzy danymi. Sieci takie potraﬁą wyróżniać klastry danych (grupy danych pod jakimś względem do siebie podobnych). Sieci neuronowe wykorzystywane są m.in. do: • rozpoznawania obiektów, • kompresji danych, 2 METODY SZTUCZNEJ INTELIGENCJI 8 • analizy serii danych i przewidywania, • detekcji anormalnych stanów pracy systemu, • analizy oraz klasteryzacji danych, • wizualizacji danych - wielowymiarowych zbiorów danych. Rysunek 3: Model neuronu oraz sieci neuronowej Rysunek 4: Przykład klasteryzacji danych 2.2.3 Algorytmy genetyczne Algorytmy genetyczne zainspirowane zostały obserwacją procesu ewolucji żywych organizmów. Koncepcja ta przeniesiona została przez Johna H. Holland’a 2 METODY SZTUCZNEJ INTELIGENCJI 9 w świat komputerów. Wystarczy założyć, że pewnym środowiskiem jest dziedzina problemu, jaki chcemy rozwiązać. Kodujemy teraz potencjalne początkowe rozwiązania jako osobniki naszej populacji. Następnie uruchamiamy proces ewolucji, w którym osobniki słabiej przystosowane eliminujemy (proces selekcji), a osobniki lepsze poddajemy procesowi krzyżowania. Skrzyżowany osobnik posiada część informacji przekazanej przez swoich rodziców (potencjalnie dobre rozwiązania). Z czasem osobniki będą coraz lepiej przystosowane do danego środowiska, czyli w naszym przypadku będą to coraz lepsze rozwiązania z przestrzeni zadania. Najczęściej działanie algorytmu przebiega następująco: 1. Losowana jest pewna populacja początkowa. 2. Populacja poddawana jest ocenie (selekcja). Najlepiej przystosowane osobniki biorą udział w procesie reprodukcji. 3. Genotypy najlepszych osobników są ze sobą kojarzone poprzez złączanie genotypów rodziców (krzyżowanie). 4. Przeprowadzana jest mutacja, czyli wprowadzenie drobnych losowych zmian. 5. Rodzi się drugie pokolenie i algorytm powraca do kroku drugiego, jeżeli nie znaleziono dostatecznie dobrego rozwiązania. W przeciwnym wypadku uzyskujemy wynik. Rysunek 5: Schemat procesu działania algorytmu genetycznego Algorytmy genetyczne stosowane są m.in. do: • harmonogramowania, 2 METODY SZTUCZNEJ INTELIGENCJI 10 • optymalizacji ułożenia elementów w układach cyfrowych, • znajdowanie optymalnych wartości parametrów, • optymalizacja długości drogi. 2.2.4 Logika rozmyta Logika rozmyta (fuzzy logic)2 , jedna z logik wielowartościowych (multi-valued logic), stanowi uogólnienie klasycznej dwuwartościowej logiki. Została zaproponowana przez Lotﬁ Zadeha w 1965 roku. W logice rozmytej między stanem 0 (fałsz) a stanem 1 (prawda) rozciąga się szereg wartości pośrednich (rysunek 6), które można kojarzyć z prawdopodobieństwem. Logika rozmyta okazała się bardzo przydatna w zastosowaniach inżynierskich, czyli tam, gdzie klasyczna logika klasyﬁkująca jedynie według kryterium prawda/fałsz nie potraﬁ skutecznie poradzić sobie z wieloma niejednoznacznościami i sprzecznościami. Logika rozmyta wykorzystywana jest m.in. w: • elektronicznych systemach sterowania (maszynami, pojazdami i automatami), • zadaniach eksploracji danych, • budowie systemów ekspertowych Rysunek 6: Przykładowa reprezentacja zbiorów za pomocą logiki rozmytej 2.3 Ocena użyteczności poszczególnych rozwiązań W poprzednim podpunkcie zostało przedstawione kilka najważniejszych metod sztucznej inteligencji. Został przedstawiony ich sposób działania oraz przykładowe zastosowania. Zwrócona została również uwaga na pewne mocne i słabe strony każdego z rozwiązań. 2 Deﬁnicja zaczerpnięta z Wikipedii, wolnej encyklopedii internetowej. 2 METODY SZTUCZNEJ INTELIGENCJI 11 Przyjrzyjmy się najważniejszym ograniczenią każdej z prezentowanych wcześniej metod: • Sieci neuronowe - brak wyjaśnień • Sieci samoorganizujące - brak możliwości rozwiązywania zadań • Systemy ekspertowe - nie są wystarczająco elastyczne • Algorytmy genetyczne - czasami nie da się zastosować, ze względu na kłopot z kodowaniem osobników, specyﬁczną dziedzinę problemu lub też inne specyﬁczne czynniki. • Systemy rozmyte - są rozmyte. . . Właściwości poszczególnych rozwiązań zostały przedstawione na rysunku 7. Oś pionowa demonstruje zdolność adaptacji metody do zmieniających się warunków pracy (w stosunku do założonych warunków początkowych), oś pozioma demonstruje przejście pomiędzy poziomem operacji na liczbach do operacji na wiedzy formalnej. Rysunek 7: Właściwości różnych metod sztucznej inteligencji 3 SYSTEMY HYBRYDOWE 12 3 3.1 Systemy hybrydowe Cele systemu hybrydowego Projektując inteligentny system informatyczny musimy zadać sobie pytanie, jaki jest cel jego pracy oraz na jakim rodzaju danych system będzie on pracował. Wcześniej wspomniany był problem akwizycji wiedzy w kontekście jej niepewności, sprzeczności itp. Przyjrzyjmy się jednak, z jakim rodzajami wiedzy mamy my, na co dzień do czynienia: • Film rozpocznie się o 8:15. [Dokładna] • Film rozpocznie się między 8:00 a 9:00. [Nieprecyzyjna] • Sądzę, że ﬁlm rozpocznie się o 8:00, ale nie jestem pewien. [Niepewna] • Film rozpocznie się około 8:00. [Przybliżona] • Możliwe, że ﬁlm rozpocznie się o 8:00. [Możliwa] • Prawdopodobnie ﬁlm rozpocznie się o 8:00 (90 %). [Prawdopodobna] • Marek mówi, że ﬁlm rozpocznie się o 8:00, ale Kasia mówi, że o 9:00. [Niespójna] • Nie wiem dokładnie, o której rozpocznie się ﬁlm, ale zazwyczaj zaczyna się o 9:00. [Niekompletna] • Naprawdę nie wiem, o której zaczyna się ﬁlm. [Nieznana] • Jestem pewien, że ﬁlm nie zaczyna się z rana. [Negacja] • Film zaczyna się 2 godziny, po poprzedniej sesji. [Względna] • Film jest grany dzisiaj o 8:00 oraz jutro o 10:00. [Alternatywna] • Film zaczyna się o 8:00, 10:00 oraz 12:00. [Opcjonalna] • Film może się rozpocząć tylko pod warunkiem, że reżyser przyjedzie. [Asocjacyjna] • W następnym miesiącu. [Temporalna] Wiedza ludzka jest często trudna do wyrażenia w formacie, na jakim zazwyczaj operują komputery. Typowym jest fakt, że nie potraﬁmy sformułować naszej wiedzy w specyﬁcznym języku (formie) jej reprezentacji. Ludzie rozwiązują problemy oraz operują na posiadanej wiedzy za pomocą następujących mechanizmów: • wnioskowanie, • analogia, 3 SYSTEMY HYBRYDOWE 13 • dedukcja, • bazowanie na wcześniejszych doświadczeniach. Naturalna inteligencja bazuje na wielu ”hybrydowych” sposobach jej reprezentacji i manipulacji. Podobnie celem stosowania systemów hybrydowych w dziedzinie sztucznej inteligencji jest: • wykorzystanie całej dostępnej wiedzy na temat specyﬁcznego problemu, • możliwości skorzystania z wielu typów informacji (symbolicznej, numerycznej, nieścisłej, nieprecyzyjnej), • zaoferowanie wielu różnych schematów rozumowania i bardziej trafnego wyszukiwania odpowiedzi na zadawane pytania, • zwiększenia ogólnej efektywności systemu i eliminacja ujemnych stron pojedynczych metod, • stworzenie wydajnych i potężnych systemów rozumowania. Aby osiągnąć te cele konstruuje się systemy hybrydowe w skład, których mogą wchodzić metody przedstawione na rysunku 8 Rysunek 8: Możliwe elementy systemu hybrydowego 3 SYSTEMY HYBRYDOWE 14 3.2 Architektury budowy systemów hybrydowych Architektury systemów hybrydowych mogą być sklasyﬁkowane według stopnia integracji i sposobu integracji. Stopień integracji jest kryterium do mierzenia stopnia integracji pomiędzy dwoma modułami systemu hybrydowego. 3.2.1 Systemy niezależne Niezależne systemy hybrydowe charakteryzują się tym, że pomiędzy poszczególnymi modułami systemu nie istnieje żadna komunikacja (rysunek 9). Każdy moduł, nie korzysta w żaden sposób z wyników pracy innego modułu. Podejścia tego typu ma tą dobrą zaletę, że daje się zrównoleglić w bardzo dużym stopniu. Niezależność dwóch pracujących systemów może służyć również badaniu efektywności obu rozwiązań. Model ten może być również przyjęty w przypadku prototypowania systemu. Rysunek 9: Model systemu niezależnego 3.2.2 Systemy transformujące System hybrydowy bazujący na modelu transformującym działa na takiej zasadzie, że wyniki pracy jednego modułu systemu są transformowane do innego modułu (np. jako dane wejściowe). Rozwiązanie takie nadaje się bardzo dobrze w przypadkach, kiedy przed przekazaniem danych do głównego modułu systemu występuje potrzeba ich wcześniejszej transformacji lub obróbki (pre-processing danych). Rysunek 10: Model systemu transformującego 3 SYSTEMY HYBRYDOWE 15 3.2.3 Systemy luźno związane W systemach hybrydowych o luźno powiązanej architekturze (rysunek 11) występuje już zjawisko komunikacji pomiędzy modułami. Najczęściej jako medium wymiany danych używane są pliki, w których jeden proces zapisuje wyniki danych inny odczytuje, po czym może nastąpić zamiana. Ważne jest, że komunikacja w tym modelu jest dwustronna. Zaletami takiej architektury jest prostota implementacji, przez co nadają się znakomicie do prototypowania pewnych rozwiązań. Dodatkowa zaleta może być fakt, że taka architektura pozwala na korzystanie z modułów zewnętrznych dostarczonych przez inne osoby lub ﬁrmy. Prostota tego rozwiązania okupiona jest niestety wysokim kosztem komunikacji (odczytu. zapisu na dysku, ewentualnego parsowania danych). Rysunek 11: Model systemu luźno powiązanego 3.2.4 Systemy zintegorwane W systemach hybrydowych zintegrowanych przesyłanie informacji pomiędzy modułami odbywa się w pamięci operacyjnej komputera(rysunek 12). Aby możliwe było wykorzystanie tej architektury w systemie hybrydowym, każdy moduł musi zostać zaprojektowany tak, aby umożliwiał komunikację z częściami systemu. Systemy takie są najczęściej dedykowanymi rozwiązaniami, które są projektowane w celu rozwiązanie konkretnego problemu. Ponieważ komunikacja procesów następuje poprzez współdzieloną pamięć operacyjną, zrównoleglenie obliczeń jest czynnością dużo bardziej skomplikowaną niż w przypadku wcześniejszych rozwiązań. Zaleta wykorzystania tej architektury jest mały koszt związany z komunikacją. W rozwiązaniu tym wykorzystuje się również ideę tablicy (blackboard ), jest to ogólnodostępny obszar pamięci, w którym wykonujące się moduły zapisują wyniki swojej pracy, tak aby wszyscy inni mogli z nich natychmiast skorzystać. 3.2.5 Systemy w pełni zintegrowane W architekturze w pełni zintegrowanego systemu hybrydowego moduły dzielą między sobą zarówno wiedzę jak również struktury danych (rysunek 13). Zdecydowanie się na tą architekturę powoduje bardzo mocne powiązanie każdego modułu z resztą systemu, jednak zaletą jest usunięcie zbytecznej redundancji 3 SYSTEMY HYBRYDOWE 16 Rysunek 12: Model systemu zintegrowanego elementów. Możliwe jest również pełne kontrolowanie jednego modułu przez inny (np. algorytm genetyczny kierujący pracą innego algorytmu genetycznego), co powoduje większe możliwości rozwiązywania problemów. Niewątpliwą wadą takich systemów jest to, że są to rozwiązania ściśle dedykowane pod dany typ problemu i istnieją małe szanse ponownego wykorzystania elementów systemu w innych projektach. Kłopotliwe może być również zapewnienie dostatecznego poziomu równoległości, ze względu na dużą ilość zależności i powiązań międzymodułowych. Rysunek 13: Model systemu w pełni zintegrowanego 3.3 Modele pracy systemu hybrydowego Istnieje kilka modeli pracy modułów systemu hybrydowego. Zostały one przedstawione na rysunku 14. Opis sposobów integracji modułów: • Przetwarzanie łańcuchowe - moduł przetwarzania symbolicznego (np. system ekspertowy), odgrywa rolę głównego procesu systemu. Jego praca może być wspierana przez prace przez pre - procesor oraz post-procesor będący np. siecią neuronową. Możliwa jest również konﬁguracja odwrotna. • Meta przetwarzanie - jeden moduł odgrywa rolę głównego procesu rozwiązującego problem inne natomiast pracują w meta - warstwie pełniąc role np. dozorcy, kontrolera wydajności, detektora błędów, w stosunku do procesu w niższej warstwie. • Przetwarzanie wewnętrzne - jeden lub więcej modułów jest osadzonych (wbudowanych) w innych. Praca elementów osadzonych jest koordy- 3 SYSTEMY HYBRYDOWE 17 nowana przez proces główny. • Przetwarzanie wspólne - oba moduły są równorzędnymi partnerami podczas rozwiązywania problemu. Każdy proces może działać bezpośrednio na środowisku, w którym pracują, oraz każdy może transmitować oraz obierać informacje od drugiego. Rysunek 14: Model przetwarzania w systemach hybrydowych 3.4 Przykładowy system hybrydowy Tradycyjne systemy ekspertowe podczas swojej pracy manipulują symbolami. Zaletami tego podejścia jest zdolność do zrozumiałej reprezentacji posiadanej wiedzy. Z drugiej zaś strony istnieją sieci neuronowe, w których wiedza zakodowana jest w postaci wag połączeń miedzyneuronowych. Wiedza ta nie jest łatwa do zinterpretowania i zanalizowania. Sieci neuronowe można traktować jak czarne pudełka, które działają, ale ciężko powiedzieć dlaczego i czy na pewno poprawnie. Jednakże sztuczne sieci neuronowe są bardzo potężnym narzędziem używanym do wydobywania (akwizycji) wiedzy z istniejących danych oraz do jej generalizacji. Sieci neuronowe z łatwością radzą sobie z informacją nieścisłą czy niepewną, która dla systemów ekspertowych stanowi poważny problem. Podczas, gdy tradycyjne systemy ekspertowe zostały zaprojektowane do przechowywania wiedzy w postaci reguł (uzyskiwanej od ludzi i przez nich rozumianej), systemy takie jak sieci neuronowe są używane do nauki i generalizowania wiedzy zawartej w praktycznych przypadkach. Połączenie tych dwóch podejść (systemów ekspertowych z sieciami neuronowymi), pozwoliło wykorzystać te dwa komplementarne podejścia w celu zwiększenia efektywności całego 3 SYSTEMY HYBRYDOWE 18 Rysunek 15: Model ideowy połączenia Systemu ekspertowego z siecią neuronową systemu. Wydobycie dodatkowych danych, wcześniej nieosiągalnych pozwoliło podnieść ogólną skuteczność wnioskowania, przy jednoczesnym zachowaniu możliwości objaśniających. Model ideowy takiego systemu ekspertowego został przedstawiony na rysunku 15. 3.5 Kierunki rozwoju systemów hybrydowych Aby stwierdzić, w jakim kierunku zmierza rozwój systemów hybrydowych, należałoby się przyjrzeć, jakie rozwiązania stosuje się przy konstruowania nowoczesnych systemów sztucznej inteligencji. Niestety informacje te są albo trudno osiągalne, albo wręcz chronione i stanowią tak zwane Know-How ﬁrm. Inną metodą jest porównanie liczby publikacji, jakie ukazują się na świecie z dziedziny systemów hybrydowych. Ilość publikacji na temat różnych rozwiązań świadczyć może zarówno o jego stopniu przydatności jak i o kierunku i potencjalnych przyszłych rozwiązań. Na rysunku 16, można zauważyć, że największa liczba publikacji dotyczy połączenia systemów ekspertowych z sieciami neuronowymi. W następnej kolejności publikowane są artykuły na temat systemów ekspertowych i logiki rozmytej, sieci neuronowej i logiki rozmytej. Najmniejszym zainteresowaniem cieszą się systemy hybrydowe próbujące wykorzystać zalety systemów ekspertowych i algorytmów genetycznych oraz systemy złożone z wielu modułów, to ostatnie podejrzewać można wiąże się z faktem bardzo dużego skomplikowania takich systemów. Nowe kierunki rozwoju systemów hybrydowych, poza badaniem skuteczności różnych połączeń poszczególnych modułów, prowadzą do stworzenia ujednoliconej architektury systemów hybrydowych oraz do standardowych modeli komunikacji. Powstał specjalny język służący komunikacji pracujących w systemie modułów - CHARON. Kolejnym krokiem jest koncepcja systemu wieloagentowego. Na system wie- 3 SYSTEMY HYBRYDOWE 19 Rysunek 16: Ilość prac naukowych na temat systemów hybrydowych loagentowy składają się agenci (niezależne jednostki), egzystujące i wchodzące w interakcje ze środowiskiem, w którym przebywają. Model agenta przedstawiony jest na rysunku 17. Obecnie implementacja systemów hybrydowych odbywa się na klasycznym ogólnodostępnym sprzęcie komputerowym. Kolejnym krokiem na drodze rozwoju systemów hybrydowych jest stworzenie dedykowanych architektur sprzętu (np. jak sterowniki rozmyte czasu rzeczywistego). Rysunek 17: Model agenta w systemie wieloagentowym LITERATURA 20 Literatura [1] Michał Białko Podstawowe własności sieci neuronowych i hybrydowych systemów eksperowych. Wydawnictwo Uczelniane Politechniki Koszalińskiej, 2000 [2] Hybrid Intelligent Systems - niebieska książka zalana kawą ;-) [3] Giarratano, Joseph and Riley, Gary. Expert Systems: Principles and Programming. 3rd Edition. PWS Publishing, Boston, MA. 1998. [4] Fernando Osorio Hybrid Systems. P.R.I.S - N.U.S. Singapore, April 2001 [5] Athanosios Tsakonas, George Dounias Hybrid Computational Intelligence Shemes in Complex Domains: An extended review [6] Rajeev Alur, Radu Grosu, Yerang Hur, Vijay Kumar, and Insup Lee Modular Speciﬁcation of Hybrid Systems in Charon URL: http://www.cis.upenn.edu/ alur,grosu,yehur,kumar,lee [7] L´szló Monostori, József Horny´k, Csaba Egresits, Zsolt J´nos Viharos a a a SOFT COMPUTING AND HYBRID AI APPROACHES TO INTELLIGENT MANUFACTURING ieaaie, 1998

Negocjacje - Techniki, Strategie

2009-01-19T16:52:00.003+01:00

Odnalazłem w swoich archiwach dokument, który pisałem jeszcze na początku studiów (więc już dość dawno temu), niemniej jednak myślę że temat jest na tyle ciekawy, że warto udostępnić ten tekst szerszemu gronu odbiorców. Życzę miłej lektury.

Negocjacje - dokument w wersji pdf (290kb)

Michal_Stanek-Negocjacje

Publish at Scribd or explore others: Academic Work negocjacje

Ubuntu 8.10 Netbeans 6.5 Segmentation Fault

2009-01-09T01:31:00.007+01:00

My Netbeans stop working on Ubuntu. I try to google the solution but the problem is more complicated than I suppose on the beginning. I investigate many things even hardware problems (but on my gentoo netbeans work absolutely fine), even reinstall system couple of times, back to previous version and install 32bit version. Nothing of those things solve this problem. The strange thing, that the segfault is replicated even if I switched the VM to another vendor for example open-jdk. If any of you experience similar problem please leave a comment.




#
# An unexpected error has been detected by Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00007ff970beb5af, pid=20424, tid=1117591888
#
# Java VM: Java HotSpot(TM) 64-Bit Server VM (11.0-b16 mixed mode linux-amd64)
# Problematic frame:
# C  [libc.so.6+0x315af]  catgets+0x1f
#
# An error report file with more information is saved as:
# /home/m/netbeans-6.5/bin/hs_err_pid20424.log
#
# If you would like to submit a bug report, please visit:
#   http://java.sun.com/webapps/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#
/usr/share/netbeans/6.1/bin/../platform8/lib/nbexec: line 470: 20424 Aborted 

"/usr/lib/jvm/jdk1.6.0_11/bin/java" -Djdk.home="/usr/lib/jvm/jdk1.6.0_11" 

-Djava.library.path=/usr/lib/jni -classpath "/usr/share/netbeans/6.1/platform8/lib/boot.jar:

 /usr/share/netbeans/6.1/platform8/lib/org-openide-modules.jar:/usr/share/netbeans 
/6.1/platform8/lib/org-openide-util.jar:/usr/lib/jvm/jdk1.6.0_11/lib/dt.jar:/usr/lib/jvm/jdk1.6.0_11/lib/tools.jar" -Dnetbeans.system_http_proxy="DIRECT"
 -Dnetbeans.system_http_non_proxy_hosts="" -Dnetbeans.dirs="/usr/share/netbeans/6.1/nb6.1:/usr/share/netbeans/6.1/ide9:/usr/share/netbeans/6.1/java2:/usr/share/netbeans/6.1/apisupport1:/usr/share/netbeans/6.1/harness:"
 -Dnetbeans.home="/usr/share/netbeans/6.1/platform8" '-Dnetbeans.importclass=org.netbeans.upgrade.AutoUpgrade' 
'-Dnetbeans.accept_license_class=org.netbeans.license.AcceptLicense' '-Xmx512m' '-client'
 '-Xss2m' '-Xms32m' '-XX:PermSize=32m' '-XX:MaxPermSize=200m' '-Xverify:none' 
'-Dapple.laf.useScreenMenuBar=true' '-Dsun.java2d.noddraw=true' 
org.netbeans.Main --userdir "/home/m/.netbeans/6.1" "--branding" "nb"


java -version
java version "1.6.0_10"
Java(TM) SE Runtime Environment (build 1.6.0_10-b33)
Java HotSpot(TM) 64-Bit Server VM (build 11.0-b15, mixed mode)


m@izmisiek:~/netbeans-6.5/bin$ cat /home/m/netbeans-6.5/bin/hs_err_pid20424.log
#
# An unexpected error has been detected by Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00007ff970beb5af, pid=20424, tid=1117591888
#
# Java VM: Java HotSpot(TM) 64-Bit Server VM (11.0-b16 mixed mode linux-amd64)
# Problematic frame:
# C  [libc.so.6+0x315af]  catgets+0x1f
#
# If you would like to submit a bug report, please visit:
#   http://java.sun.com/webapps/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#

---------------  T H R E A D  ---------------

Current thread (0x00007ff93d7df800):  JavaThread "AWT-EventQueue-0" [_thread_in_native, id=20450, stack(0x00000000427d1000,0x00000000429d2000)]

siginfo:si_signo=SIGSEGV: si_errno=0, si_code=1 (SEGV_MAPERR), si_addr=0x0000000000000008

Registers:
RAX=0x00007ff93f220490, RBX=0x0000000000000001, RCX=0x00007ff93f0f06cd, RDX=0x0000000000000013
RSP=0x00000000429d0008, RBP=0x00007ff93f0f06cd, RSI=0x0000000000000013, RDI=0x0000000000000000
R8 =0x00000000408db350, R9 =0x0000000000000000, R10=0x00000000429cfda0, R11=0x00007ff970beb590
R12=0x0000000000000113, R13=0x00000000408db350, R14=0x000000000000000f, R15=0x00000000429d0520
RIP=0x00007ff970beb5af, EFL=0x0000000000010202, CSGSFS=0x0000000000000033, ERR=0x0000000000000004
  TRAPNO=0x000000000000000e

Top of Stack: (sp=0x00000000429d0008)
0x00000000429d0008:   00000000408d4280 00000000429d0040
0x00000000429d0018:   00007ff93f04dc36 00000000408db350
0x00000000429d0028:   00007ff93813eae0 00007ff93813eae0
0x00000000429d0038:   00007ff93d7e1aa0 00000000429d0090
0x00000000429d0048:   00007ff93f04e855 0000000000a2e701
0x00000000429d0058:   0000000000000115 000000000001a9a0
0x00000000429d0068:   00000000408db350 00007ff93ef09590
0x00000000429d0078:   0000000000000113 0000000000000115
0x00000000429d0088:   00007ff93d7e1aa0 00007ff93d7df9c0
0x00000000429d0098:   00007ff93ef0969e 00007ff93f20e1f0
0x00000000429d00a8:   00000000429d0130 00000000408d4280
0x00000000429d00b8:   00007ff93ef0a363 00000000429d00e0
0x00000000429d00c8:   00007ff970444c37 0000000000000000
0x00000000429d00d8:   00007ff93814a4a0 00007ff93814a4a0
0x00000000429d00e8:   00000000705ad0c6 00000000408db350
0x00000000429d00f8:   0001000000000000 00007ff93d7e0a20
0x00000000429d0108:   00007ff93d7a7b50 00007ff93ea77120
0x00000000429d0118:   0000000000000000 00000000429d0510
0x00000000429d0128:   0000000000000000 00007ff93e86a192
0x00000000429d0138:   0000000000000000 00007ff93e86a218
0x00000000429d0148:   0000000000000000 00007ff93e86a168
0x00000000429d0158:   00007ff9381422f0 00007ff93e86973a
0x00000000429d0168:   0000000000000020 00007ff93e869743
0x00000000429d0178:   0000000000000018 00007ff93e869865
0x00000000429d0188:   0000000000000000 00007ff93e869a15
0x00000000429d0198:   0000000000000000 00007ff93e869a17
0x00000000429d01a8:   0000000000000000 00007ff93e869a08
0x00000000429d01b8:   0000000000000000 00007ff93e86978a
0x00000000429d01c8:   0000000000000000 00007ff93f0dcb0b
0x00000000429d01d8:   00007ff93d7e18c0 00007ff93f0dcb27
0x00000000429d01e8:   00007ff93d7e1990 00007ff93f0dcb35
0x00000000429d01f8:   00007ff93d7e1a60 00007ff93f0de23f 

Instructions: (pc=0x00007ff970beb5af)
0x00007ff970beb59f:   00 00 83 c6 01 85 f6 7e 76 85 d2 78 72 0f af d6
0x00007ff970beb5af:   4c 8b 47 08 48 8b 4f 18 48 63 d2 4f 8d 1c 40 48 

Stack: [0x00000000427d1000,0x00000000429d2000],  sp=0x00000000429d0008,  free space=2044k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
C  [libc.so.6+0x315af]  catgets+0x1f

Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)
j  sun.awt.motif.MWindowPeer.pCreate(Lsun/awt/motif/MComponentPeer;Ljava/lang/String;)V+0
j  sun.awt.motif.MWindowPeer.create(Lsun/awt/motif/MComponentPeer;)V+12
j  sun.awt.motif.MComponentPeer.init(Ljava/awt/Component;)V+31
j  sun.awt.motif.MWindowPeer.init(Ljava/awt/Window;)V+102
j  sun.awt.motif.MFramePeer.(Ljava/awt/Frame;)V+159
j  sun.awt.motif.MToolkit.createFrame(Ljava/awt/Frame;)Ljava/awt/peer/FramePeer;+5
j  java.awt.Frame.addNotify()V+20
j  java.awt.Window.pack()V+28
j  org.netbeans.core.startup.Splash.center(Ljava/awt/Window;)V+1
j  org.netbeans.core.startup.Splash$SplashRunner.run()V+11
j  java.awt.event.InvocationEvent.dispatch()V+47
j  java.awt.EventQueue.dispatchEvent(Ljava/awt/AWTEvent;)V+26
j  java.awt.EventDispatchThread.pumpOneEventForFilters(I)Z+204
j  java.awt.EventDispatchThread.pumpEventsForFilter(ILjava/awt/Conditional;Ljava/awt/EventFilter;)V+30
j  java.awt.EventDispatchThread.pumpEventsForHierarchy(ILjava/awt/Conditional;Ljava/awt/Component;)V+11
j  java.awt.EventDispatchThread.pumpEvents(ILjava/awt/Conditional;)V+4
j  java.awt.EventDispatchThread.pumpEvents(Ljava/awt/Conditional;)V+3
j  java.awt.EventDispatchThread.run()V+9
v  ~StubRoutines::call_stub

---------------  P R O C E S S  ---------------

Java Threads: ( => current thread )
=>0x00007ff93d7df800 JavaThread "AWT-EventQueue-0" [_thread_in_native, id=20450, stack(0x00000000427d1000,0x00000000429d2000)]
  0x00007ff93d7ba400 JavaThread "AWT-Motif" daemon [_thread_blocked, id=20449, stack(0x00000000425d0000,0x00000000427d1000)]
  0x00007ff93d7b5c00 JavaThread "AWT-Shutdown" [_thread_blocked, id=20448, stack(0x00000000423cf000,0x00000000425d0000)]
  0x00007ff938150c00 JavaThread "Java2D Disposer" daemon [_thread_blocked, id=20447, stack(0x00000000421ce000,0x00000000423cf000)]
  0x0000000040868000 JavaThread "Timer-0" daemon [_thread_blocked, id=20446, stack(0x00000000402f0000,0x00000000404f1000)]
  0x00000000408da000 JavaThread "main" [_thread_in_vm_trans, id=20445, stack(0x0000000041fcd000,0x00000000421ce000)]
  0x0000000040948400 JavaThread "Active Reference Queue Daemon" daemon [_thread_blocked, id=20436, stack(0x0000000040d23000,0x0000000040f24000)]
  0x000000004084ec00 JavaThread "Low Memory Detector" daemon [_thread_blocked, id=20434, stack(0x000000004181d000,0x0000000041a1e000)]
  0x000000004084c000 JavaThread "CompilerThread1" daemon [_thread_blocked, id=20433, stack(0x000000004171c000,0x000000004181d000)]
  0x0000000040848400 JavaThread "CompilerThread0" daemon [_thread_in_native, id=20432, stack(0x00000000414ec000,0x00000000415ed000)]
  0x0000000040846400 JavaThread "Signal Dispatcher" daemon [_thread_blocked, id=20431, stack(0x00000000412eb000,0x00000000414ec000)]
  0x0000000040827400 JavaThread "Finalizer" daemon [_thread_blocked, id=20430, stack(0x0000000041ccb000,0x0000000041ecc000)]
  0x0000000040820000 JavaThread "Reference Handler" daemon [_thread_blocked, id=20429, stack(0x0000000041aca000,0x0000000041ccb000)]
  0x0000000040799c00 JavaThread "main" [_thread_blocked, id=20425, stack(0x0000000040b22000,0x0000000040d23000)]

Other Threads:
  0x000000004081a800 VMThread [stack: 0x000000004161b000,0x000000004171c000] [id=20428]
  0x0000000040851000 WatcherThread [stack: 0x0000000041ecc000,0x0000000041fcd000] [id=20435]

VM state:not at safepoint (normal execution)

VM Mutex/Monitor currently owned by a thread: None

Heap
 PSYoungGen      total 9536K, used 5956K [0x00007ff9616d0000, 0x00007ff962170000, 0x00007ff96c170000)
  eden space 8192K, 72% used [0x00007ff9616d0000,0x00007ff961ca13e0,0x00007ff961ed0000)
  from space 1344K, 0% used [0x00007ff962020000,0x00007ff962020000,0x00007ff962170000)
  to   space 1344K, 0% used [0x00007ff961ed0000,0x00007ff961ed0000,0x00007ff962020000)
 PSOldGen        total 21888K, used 0K [0x00007ff94c170000, 0x00007ff94d6d0000, 0x00007ff9616d0000)
  object space 21888K, 0% used [0x00007ff94c170000,0x00007ff94c170000,0x00007ff94d6d0000)
 PSPermGen       total 32768K, used 10263K [0x00007ff93f970000, 0x00007ff941970000, 0x00007ff94c170000)
  object space 32768K, 31% used [0x00007ff93f970000,0x00007ff940375d30,0x00007ff941970000)

Dynamic libraries:
40000000-40009000 r-xp 00000000 08:01 168553                             /usr/lib/jvm/jdk1.6.0_11/bin/java
40108000-4010a000 rwxp 00008000 08:01 168553                             /usr/lib/jvm/jdk1.6.0_11/bin/java
402f0000-402f3000 ---p 402f0000 00:00 0 
402f3000-404f1000 rwxp 402f3000 00:00 0 
40791000-40b0e000 rwxp 40791000 00:00 0                                  [heap]
40b22000-40b25000 ---p 40b22000 00:00 0 
40b25000-40d23000 rwxp 40b25000 00:00 0 
40d23000-40d26000 ---p 40d23000 00:00 0 
40d26000-40f24000 rwxp 40d26000 00:00 0 
410e9000-410ea000 ---p 410e9000 00:00 0 
410ea000-411ea000 rwxp 410ea000 00:00 0 
411ea000-411eb000 ---p 411ea000 00:00 0 
411eb000-412eb000 rwxp 411eb000 00:00 0 
412eb000-412ee000 ---p 412eb000 00:00 0 
412ee000-414ec000 rwxp 412ee000 00:00 0 
414ec000-414ef000 ---p 414ec000 00:00 0 
414ef000-415ed000 rwxp 414ef000 00:00 0 
4161b000-4161c000 ---p 4161b000 00:00 0 
4161c000-4171c000 rwxp 4161c000 00:00 0 
4171c000-4171f000 ---p 4171c000 00:00 0 
4171f000-4181d000 rwxp 4171f000 00:00 0 
4181d000-41820000 ---p 4181d000 00:00 0 
41820000-41a1e000 rwxp 41820000 00:00 0 
41aca000-41acd000 ---p 41aca000 00:00 0 
41acd000-41ccb000 rwxp 41acd000 00:00 0 
41ccb000-41cce000 ---p 41ccb000 00:00 0 
41cce000-41ecc000 rwxp 41cce000 00:00 0 
41ecc000-41ecd000 ---p 41ecc000 00:00 0 
41ecd000-41fcd000 rwxp 41ecd000 00:00 0 
41fcd000-41fd0000 ---p 41fcd000 00:00 0 
41fd0000-421ce000 rwxp 41fd0000 00:00 0 
421ce000-421d1000 ---p 421ce000 00:00 0 
421d1000-423cf000 rwxp 421d1000 00:00 0 
423cf000-423d2000 ---p 423cf000 00:00 0 
423d2000-425d0000 rwxp 423d2000 00:00 0 
425d0000-425d3000 ---p 425d0000 00:00 0 
425d3000-427d1000 rwxp 425d3000 00:00 0 
427d1000-427d4000 ---p 427d1000 00:00 0 
427d4000-429d2000 rwxp 427d4000 00:00 0 
7ff938000000-7ff9381f2000 rwxp 7ff938000000 00:00 0 
7ff9381f2000-7ff93c000000 ---p 7ff9381f2000 00:00 0 
7ff93cbb6000-7ff93cbbb000 r-xp 00000000 08:01 8936                       /usr/lib/libXfixes.so.3.1.0
7ff93cbbb000-7ff93cdba000 ---p 00005000 08:01 8936                       /usr/lib/libXfixes.so.3.1.0
7ff93cdba000-7ff93cdbb000 rwxp 00004000 08:01 8936                       /usr/lib/libXfixes.so.3.1.0
7ff93cdbb000-7ff93cdc4000 r-xp 00000000 08:01 8956                       /usr/lib/libXrender.so.1.3.0
7ff93cdc4000-7ff93cfc3000 ---p 00009000 08:01 8956                       /usr/lib/libXrender.so.1.3.0
7ff93cfc3000-7ff93cfc4000 r-xp 00008000 08:01 8956                       /usr/lib/libXrender.so.1.3.0
7ff93cfc4000-7ff93cfc5000 rwxp 00009000 08:01 8956                       /usr/lib/libXrender.so.1.3.0
7ff93cfc5000-7ff93cfce000 r-xp 00000000 08:01 8926                       /usr/lib/libXcursor.so.1.0.2
7ff93cfce000-7ff93d1ce000 ---p 00009000 08:01 8926                       /usr/lib/libXcursor.so.1.0.2
7ff93d1ce000-7ff93d1cf000 rwxp 00009000 08:01 8926                       /usr/lib/libXcursor.so.1.0.2
7ff93d1cf000-7ff93d1d6000 r-xp 00000000 08:01 169087                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libnio.so
7ff93d1d6000-7ff93d2d5000 ---p 00007000 08:01 169087                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libnio.so
7ff93d2d5000-7ff93d2d7000 rwxp 00006000 08:01 169087                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libnio.so
7ff93d2d7000-7ff93d2ea000 r-xp 00000000 08:01 169086                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libnet.so
7ff93d2ea000-7ff93d3eb000 ---p 00013000 08:01 169086                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libnet.so
7ff93d3eb000-7ff93d3ee000 rwxp 00014000 08:01 169086                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libnet.so
7ff93d3ee000-7ff93d46c000 r-xp 00000000 08:01 169095                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libfontmanager.so
7ff93d46c000-7ff93d56e000 ---p 0007e000 08:01 169095                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libfontmanager.so
7ff93d56e000-7ff93d584000 rwxp 00080000 08:01 169095                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libfontmanager.so
7ff93d584000-7ff93d595000 rwxp 7ff93d584000 00:00 0 
7ff93d595000-7ff93d59a000 r-xp 00000000 08:01 8930                       /usr/lib/libXdmcp.so.6.0.0
7ff93d59a000-7ff93d799000 ---p 00005000 08:01 8930                       /usr/lib/libXdmcp.so.6.0.0
7ff93d799000-7ff93d79a000 rwxp 00004000 08:01 8930                       /usr/lib/libXdmcp.so.6.0.0
7ff93d79a000-7ff93d89a000 rwxp 7ff93d79a000 00:00 0 
7ff93d8c0000-7ff93d8db000 r-xp 00000000 08:01 9863                       /usr/lib/libxcb.so.1.0.0
7ff93d8db000-7ff93dada000 ---p 0001b000 08:01 9863                       /usr/lib/libxcb.so.1.0.0
7ff93dada000-7ff93dadb000 r-xp 0001a000 08:01 9863                       /usr/lib/libxcb.so.1.0.0
7ff93dadb000-7ff93dadc000 rwxp 0001b000 08:01 9863                       /usr/lib/libxcb.so.1.0.0
7ff93dadc000-7ff93dadd000 r-xp 00000000 08:01 9861                       /usr/lib/libxcb-xlib.so.0.0.0
7ff93dadd000-7ff93dcdc000 ---p 00001000 08:01 9861                       /usr/lib/libxcb-xlib.so.0.0.0
7ff93dcdc000-7ff93dcdd000 r-xp 00000000 08:01 9861                       /usr/lib/libxcb-xlib.so.0.0.0
7ff93dcdd000-7ff93dcde000 rwxp 00001000 08:01 9861                       /usr/lib/libxcb-xlib.so.0.0.0
7ff93dcde000-7ff93dcf5000 r-xp 00000000 08:01 8878                       /usr/lib/libICE.so.6.3.0
7ff93dcf5000-7ff93def4000 ---p 00017000 08:01 8878                       /usr/lib/libICE.so.6.3.0
7ff93def4000-7ff93def6000 rwxp 00016000 08:01 8878                       /usr/lib/libICE.so.6.3.0
7ff93def6000-7ff93def9000 rwxp 7ff93def6000 00:00 0 
7ff93def9000-7ff93df01000 r-xp 00000000 08:01 8907                       /usr/lib/libSM.so.6.0.0
7ff93df01000-7ff93e100000 ---p 00008000 08:01 8907                       /usr/lib/libSM.so.6.0.0
7ff93e100000-7ff93e101000 r-xp 00007000 08:01 8907                       /usr/lib/libSM.so.6.0.0
7ff93e101000-7ff93e102000 rwxp 00008000 08:01 8907                       /usr/lib/libSM.so.6.0.0
7ff93e102000-7ff93e104000 r-xp 00000000 08:01 8919                       /usr/lib/libXau.so.6.0.0
7ff93e104000-7ff93e303000 ---p 00002000 08:01 8919                       /usr/lib/libXau.so.6.0.0
7ff93e303000-7ff93e304000 rwxp 00001000 08:01 8919                       /usr/lib/libXau.so.6.0.0
7ff93e304000-7ff93e30d000 r-xp 00000000 08:01 8942                       /usr/lib/libXi.so.6.0.0
7ff93e30d000-7ff93e50d000 ---p 00009000 08:01 8942                       /usr/lib/libXi.so.6.0.0
7ff93e50d000-7ff93e50e000 r-xp 00009000 08:01 8942                       /usr/lib/libXi.so.6.0.0
7ff93e50e000-7ff93e50f000 rwxp 0000a000 08:01 8942                       /usr/lib/libXi.so.6.0.0
7ff93e50f000-7ff93e612000 r-xp 00000000 08:01 14916                      /usr/lib/libX11.so.6.2.0
7ff93e612000-7ff93e812000 ---p 00103000 08:01 14916                      /usr/lib/libX11.so.6.2.0
7ff93e812000-7ff93e813000 r-xp 00103000 08:01 14916                      /usr/lib/libX11.so.6.2.0
7ff93e813000-7ff93e817000 rwxp 00104000 08:01 14916                      /usr/lib/libX11.so.6.2.0
7ff93e817000-7ff93e874000 r-xp 00000000 08:01 8960                       /usr/lib/libXt.so.6.0.0
7ff93e874000-7ff93ea74000 ---p 0005d000 08:01 8960                       /usr/lib/libXt.so.6.0.0
7ff93ea74000-7ff93ea7a000 rwxp 0005d000 08:01 8960                       /usr/lib/libXt.so.6.0.0
7ff93ea7a000-7ff93ea7b000 rwxp 7ff93ea7a000 00:00 0 
7ff93ea7b000-7ff93ea8b000 r-xp 00000000 08:01 8934                       /usr/lib/libXext.so.6.4.0
7ff93ea8b000-7ff93ec8b000 ---p 00010000 08:01 8934                       /usr/lib/libXext.so.6.4.0
7ff93ec8b000-7ff93ec8d000 rwxp 00010000 08:01 8934                       /usr/lib/libXext.so.6.4.0
7ff93ec8d000-7ff93ec92000 r-xp 00000000 08:01 8962                       /usr/lib/libXtst.so.6.1.0
7ff93ec92000-7ff93ee92000 ---p 00005000 08:01 8962                       /usr/lib/libXtst.so.6.1.0
7ff93ee92000-7ff93ee93000 rwxp 00005000 08:01 8962                       /usr/lib/libXtst.so.6.1.0
7ff93eea6000-7ff93f10d000 r-xp 00000000 08:01 169106                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/motif21/libmawt.so
7ff93f10d000-7ff93f20e000 ---p 00267000 08:01 169106                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/motif21/libmawt.so
7ff93f20e000-7ff93f262000 rwxp 00268000 08:01 169106                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/motif21/libmawt.so
7ff93f262000-7ff93f265000 rwxp 7ff93f262000 00:00 0 
7ff93f265000-7ff93f2ef000 r-xp 00000000 08:01 169128                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libawt.so
7ff93f2ef000-7ff93f3ee000 ---p 0008a000 08:01 169128                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libawt.so
7ff93f3ee000-7ff93f406000 rwxp 00089000 08:01 169128                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libawt.so
7ff93f406000-7ff93f42b000 rwxp 7ff93f406000 00:00 0 
7ff93f42b000-7ff93f489000 r-xs 00b8b000 08:01 169475                     /usr/lib/jvm/jdk1.6.0_11/lib/tools.jar
7ff93f489000-7ff93f490000 r-xs 00000000 08:01 11672                      /usr/lib/gconv/gconv-modules.cache
7ff93f490000-7ff93f4cf000 r-xp 00000000 08:01 12899                      /usr/lib/locale/pl_PL.utf8/LC_CTYPE
7ff93f4cf000-7ff93f544000 rwxp 7ff93f4cf000 00:00 0 
7ff93f544000-7ff93f6d4000 r-xs 02ef0000 08:01 169188                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/rt.jar
7ff93f6d4000-7ff93f70c000 rwxp 7ff93f6d4000 00:00 0 
7ff93f70c000-7ff93f760000 rwxp 7ff93f70c000 00:00 0 
7ff93f760000-7ff93f76b000 rwxp 7ff93f760000 00:00 0 
7ff93f76b000-7ff93f80b000 rwxp 7ff93f76b000 00:00 0 
7ff93f80b000-7ff93f81b000 rwxp 7ff93f80b000 00:00 0 
7ff93f81b000-7ff93f86f000 rwxp 7ff93f81b000 00:00 0 
7ff93f86f000-7ff93f87a000 rwxp 7ff93f86f000 00:00 0 
7ff93f87a000-7ff93f919000 rwxp 7ff93f87a000 00:00 0 
7ff93f919000-7ff93f91f000 rwxp 7ff93f919000 00:00 0 
7ff93f91f000-7ff93f96f000 rwxp 7ff93f91f000 00:00 0 
7ff93f96f000-7ff941970000 rwxp 7ff93f96f000 00:00 0 
7ff941970000-7ff94c170000 rwxp 7ff941970000 00:00 0 
7ff94c170000-7ff94d6d0000 rwxp 7ff94c170000 00:00 0 
7ff94d6d0000-7ff9616d0000 rwxp 7ff94d6d0000 00:00 0 
7ff9616d0000-7ff962170000 rwxp 7ff9616d0000 00:00 0 
7ff962170000-7ff96c170000 rwxp 7ff962170000 00:00 0 
7ff96c17c000-7ff96c3ec000 rwxp 7ff96c17c000 00:00 0 
7ff96c3ec000-7ff96f17c000 rwxp 7ff96c3ec000 00:00 0 
7ff96f17c000-7ff96f18a000 r-xp 00000000 08:01 169097                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libzip.so
7ff96f18a000-7ff96f28c000 ---p 0000e000 08:01 169097                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libzip.so
7ff96f28c000-7ff96f28f000 rwxp 00010000 08:01 169097                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libzip.so
7ff96f28f000-7ff96f290000 rwxp 7ff96f28f000 00:00 0 
7ff96f290000-7ff96f2b9000 r-xp 00000000 08:01 169110                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libjava.so
7ff96f2b9000-7ff96f3b8000 ---p 00029000 08:01 169110                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libjava.so
7ff96f3b8000-7ff96f3bf000 rwxp 00028000 08:01 169110                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libjava.so
7ff96f3bf000-7ff96f3cc000 r-xp 00000000 08:01 169092                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libverify.so
7ff96f3cc000-7ff96f4cb000 ---p 0000d000 08:01 169092                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libverify.so
7ff96f4cb000-7ff96f4ce000 rwxp 0000c000 08:01 169092                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/libverify.so
7ff96f4ce000-7ff96f4d9000 r-xp 00000000 08:01 2539                       /lib/libnss_files-2.8.90.so
7ff96f4d9000-7ff96f6d8000 ---p 0000b000 08:01 2539                       /lib/libnss_files-2.8.90.so
7ff96f6d8000-7ff96f6d9000 r-xp 0000a000 08:01 2539                       /lib/libnss_files-2.8.90.so
7ff96f6d9000-7ff96f6da000 rwxp 0000b000 08:01 2539                       /lib/libnss_files-2.8.90.so
7ff96f6da000-7ff96f6e4000 r-xp 00000000 08:01 2549                       /lib/libnss_nis-2.8.90.so
7ff96f6e4000-7ff96f8e3000 ---p 0000a000 08:01 2549                       /lib/libnss_nis-2.8.90.so
7ff96f8e3000-7ff96f8e4000 r-xp 00009000 08:01 2549                       /lib/libnss_nis-2.8.90.so
7ff96f8e4000-7ff96f8e5000 rwxp 0000a000 08:01 2549                       /lib/libnss_nis-2.8.90.so
7ff96f8e5000-7ff96f8ed000 r-xp 00000000 08:01 2535                       /lib/libnss_compat-2.8.90.so
7ff96f8ed000-7ff96faec000 ---p 00008000 08:01 2535                       /lib/libnss_compat-2.8.90.so
7ff96faec000-7ff96faed000 r-xp 00007000 08:01 2535                       /lib/libnss_compat-2.8.90.so
7ff96faed000-7ff96faee000 rwxp 00008000 08:01 2535                       /lib/libnss_compat-2.8.90.so
7ff96faee000-7ff96fb04000 r-xp 00000000 08:01 2533                       /lib/libnsl-2.8.90.so
7ff96fb04000-7ff96fd03000 ---p 00016000 08:01 2533                       /lib/libnsl-2.8.90.so
7ff96fd03000-7ff96fd04000 r-xp 00015000 08:01 2533                       /lib/libnsl-2.8.90.so
7ff96fd04000-7ff96fd05000 rwxp 00016000 08:01 2533                       /lib/libnsl-2.8.90.so
7ff96fd05000-7ff96fd07000 rwxp 7ff96fd05000 00:00 0 
7ff96fd07000-7ff96fd0e000 r-xp 00000000 08:01 169099                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/native_threads/libhpi.so
7ff96fd0e000-7ff96fe0f000 ---p 00007000 08:01 169099                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/native_threads/libhpi.so
7ff96fe0f000-7ff96fe11000 rwxp 00008000 08:01 169099                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/native_threads/libhpi.so
7ff96fe11000-7ff96fe12000 rwxp 7ff96fe11000 00:00 0 
7ff96fe12000-7ff96fe1a000 r-xp 00000000 08:01 2575                       /lib/librt-2.8.90.so
7ff96fe1a000-7ff970019000 ---p 00008000 08:01 2575                       /lib/librt-2.8.90.so
7ff970019000-7ff97001a000 r-xp 00007000 08:01 2575                       /lib/librt-2.8.90.so
7ff97001a000-7ff97001b000 rwxp 00008000 08:01 2575                       /lib/librt-2.8.90.so
7ff97001b000-7ff97009f000 r-xp 00000000 08:01 2526                       /lib/libm-2.8.90.so
7ff97009f000-7ff97029e000 ---p 00084000 08:01 2526                       /lib/libm-2.8.90.so
7ff97029e000-7ff97029f000 r-xp 00083000 08:01 2526                       /lib/libm-2.8.90.so
7ff97029f000-7ff9702a0000 rwxp 00084000 08:01 2526                       /lib/libm-2.8.90.so
7ff9702a0000-7ff97092d000 r-xp 00000000 08:01 169116                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/server/libjvm.so
7ff97092d000-7ff970a2c000 ---p 0068d000 08:01 169116                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/server/libjvm.so
7ff970a2c000-7ff970b7d000 rwxp 0068c000 08:01 169116                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/server/libjvm.so
7ff970b7d000-7ff970bba000 rwxp 7ff970b7d000 00:00 0 
7ff970bba000-7ff970d23000 r-xp 00000000 08:01 2492                       /lib/libc-2.8.90.so
7ff970d23000-7ff970f22000 ---p 00169000 08:01 2492                       /lib/libc-2.8.90.so
7ff970f22000-7ff970f26000 r-xp 00168000 08:01 2492                       /lib/libc-2.8.90.so
7ff970f26000-7ff970f27000 rwxp 0016c000 08:01 2492                       /lib/libc-2.8.90.so
7ff970f27000-7ff970f2c000 rwxp 7ff970f27000 00:00 0 
7ff970f2c000-7ff970f2e000 r-xp 00000000 08:01 2507                       /lib/libdl-2.8.90.so
7ff970f2e000-7ff97112e000 ---p 00002000 08:01 2507                       /lib/libdl-2.8.90.so
7ff97112e000-7ff97112f000 r-xp 00002000 08:01 2507                       /lib/libdl-2.8.90.so
7ff97112f000-7ff971130000 rwxp 00003000 08:01 2507                       /lib/libdl-2.8.90.so
7ff971130000-7ff971147000 r-xp 00000000 08:01 2569                       /lib/libpthread-2.8.90.so
7ff971147000-7ff971346000 ---p 00017000 08:01 2569                       /lib/libpthread-2.8.90.so
7ff971346000-7ff971347000 r-xp 00016000 08:01 2569                       /lib/libpthread-2.8.90.so
7ff971347000-7ff971348000 rwxp 00017000 08:01 2569                       /lib/libpthread-2.8.90.so
7ff971348000-7ff97134c000 rwxp 7ff971348000 00:00 0 
7ff97134c000-7ff97136b000 r-xp 00000000 08:01 2472                       /lib/ld-2.8.90.so
7ff971371000-7ff971377000 r-xs 0001e000 08:01 169477                     /usr/lib/jvm/jdk1.6.0_11/lib/dt.jar
7ff971377000-7ff97137e000 r-xs 0007e000 08:01 140109                     /usr/share/netbeans/platform8/lib/org-openide-util.jar
7ff97137e000-7ff97137f000 r-xs 00004000 08:01 140110                     /usr/share/netbeans/platform8/lib/org-openide-modules.jar
7ff97137f000-7ff971380000 r-xs 0003b000 08:01 140981                     /usr/share/netbeans/6.1/nb6.1/core/locale/core_nb.jar
7ff971380000-7ff971382000 r-xs 00037000 08:01 140982                     /usr/share/netbeans/6.1/nb6.1/core/org-netbeans-upgrader.jar
7ff971382000-7ff971387000 r-xs 00065000 08:01 140106                     /usr/share/netbeans/platform8/core/org-openide-filesystems.jar
7ff971387000-7ff971391000 rwxp 7ff971387000 00:00 0 
7ff971391000-7ff971447000 rwxp 7ff971391000 00:00 0 
7ff971447000-7ff971449000 rwxp 7ff971447000 00:00 0 
7ff971449000-7ff971450000 r-xp 00000000 08:01 169082                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/jli/libjli.so
7ff971450000-7ff971551000 ---p 00007000 08:01 169082                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/jli/libjli.so
7ff971551000-7ff971553000 rwxp 00008000 08:01 169082                     /usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/jli/libjli.so
7ff971553000-7ff971554000 rwxp 7ff971553000 00:00 0 
7ff971555000-7ff97155a000 r-xs 00087000 08:01 140107                     /usr/share/netbeans/platform8/core/core.jar
7ff97155a000-7ff97155d000 r-xs 00034000 08:01 140111                     /usr/share/netbeans/platform8/lib/boot.jar
7ff97155d000-7ff971565000 rwxs 00000000 08:01 871                        /tmp/hsperfdata_m/20424
7ff971565000-7ff971566000 rwxp 7ff971565000 00:00 0 
7ff971566000-7ff971567000 r-xp 7ff971566000 00:00 0 
7ff971567000-7ff97156a000 rwxp 7ff971567000 00:00 0 
7ff97156a000-7ff97156b000 r-xp 0001e000 08:01 2472                       /lib/ld-2.8.90.so
7ff97156b000-7ff97156c000 rwxp 0001f000 08:01 2472                       /lib/ld-2.8.90.so
7fff79557000-7fff7956c000 rwxp 7ffffffea000 00:00 0                      [stack]
7fff795ff000-7fff79600000 r-xp 7fff795ff000 00:00 0                      [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]

VM Arguments:
jvm_args: -Djdk.home=/usr/lib/jvm/jdk1.6.0_11 -Djava.library.path=/usr/lib/jni -Dnetbeans.system_http_proxy=DIRECT -Dnetbeans.system_http_non_proxy_hosts= -Dnetbeans.dirs=/usr/share/netbeans/6.1/nb6.1:/usr/share/netbeans/6.1/ide9:/usr/share/netbeans/6.1/java2:/usr/share/netbeans/6.1/apisupport1:/usr/share/netbeans/6.1/harness: -Dnetbeans.home=/usr/share/netbeans/6.1/platform8 -Dnetbeans.importclass=org.netbeans.upgrade.AutoUpgrade -Dnetbeans.accept_license_class=org.netbeans.license.AcceptLicense -Xmx512m -Xss2m -Xms32m -XX:PermSize=32m -XX:MaxPermSize=200m -Xverify:none -Dapple.laf.useScreenMenuBar=true -Dsun.java2d.noddraw=true 
java_command: org.netbeans.Main --userdir /home/m/.netbeans/6.1 --branding nb
Launcher Type: SUN_STANDARD

Environment Variables:
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
USERNAME=m
LD_LIBRARY_PATH=/usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64/server:/usr/lib/jvm/jdk1.6.0_11/jre/lib/amd64:/usr/lib/jvm/jdk1.6.0_11/jre/../lib/amd64
SHELL=/bin/bash
DISPLAY=:0.0

Signal Handlers:
SIGSEGV: [libjvm.so+0x5fcb80], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGBUS: [libjvm.so+0x5fcb80], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGFPE: [libjvm.so+0x4e0d10], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGPIPE: [libjvm.so+0x4e0d10], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGXFSZ: [libjvm.so+0x4e0d10], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGILL: [libjvm.so+0x4e0d10], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGUSR1: SIG_DFL, sa_mask[0]=0x00000000, sa_flags=0x00000000
SIGUSR2: [libjvm.so+0x4e3430], sa_mask[0]=0x00000000, sa_flags=0x10000004
SIGHUP: [libjvm.so+0x4e3180], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGINT: SIG_IGN, sa_mask[0]=0x00000000, sa_flags=0x00000000
SIGTERM: [libjvm.so+0x4e3180], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
SIGQUIT: [libjvm.so+0x4e3180], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004


---------------  S Y S T E M  ---------------

OS:lenny/sid

uname:Linux 2.6.27-9-generic #1 SMP Thu Nov 20 22:15:32 UTC 2008 x86_64
libc:glibc 2.8.90 NPTL 2.8.90 
rlimit: STACK 8192k, CORE 0k, NPROC 40448, NOFILE 1024, AS infinity
load average:0.43 0.82 0.61

CPU:total 2 (2 cores per cpu, 1 threads per core) family 6 model 7 stepping 6, cmov, cx8, fxsr, mmx, sse, sse2, sse3, ssse3

Memory: 4k page, physical 3988812k(1149728k free), swap 4883752k(4883752k free)

vm_info: Java HotSpot(TM) 64-Bit Server VM (11.0-b16) for linux-amd64 JRE (1.6.0_11-b03), built on Nov 10 2008 01:28:14 by "java_re" with gcc 3.2.2 (SuSE Linux)

time: Fri Jan  9 01:26:01 2009
elapsed time: 10 seconds

Set SUN JDK as default Java Machine in UBUNTU

2009-01-05T21:20:00.002+01:00


 sudo update-java-alternatives -s java-6-sun

Weighted fulltext search in MySQL

2009-01-05T14:01:00.002+01:00


SELECT
*,
(MATCH (column1) AGAINST ('$query' IN BOOLEAN MODE)*100) +
(MATCH (column2) AGAINST ('$query' IN BOOLEAN MODE)*10) +
MATCH (column3) AGAINST ('$query' IN BOOLEAN MODE) AS rating
FROM
table
WHERE
MATCH (column1,column2,column3) AGAINST ('$query' IN BOOLEAN MODE)
ORDER BY
rating DESC
LIMIT 0,10

MPlayer Polskie czcionki

2009-01-03T00:57:00.001+01:00

Źródło: http://forum.ubuntu.pl/showthread.php?t=38659

1. Ściągamy potrzebne elementy :
czcionka ttf :


wget http://aed_221.webpark.pl/subfont.ttf

czcionka RAW :


wget http://aed_221.webpark.pl/iso-8859-2-win-1250.zip

2. Kopiujemy pliki w odpowiednie miejsce :

Katalog na którym pracujemy to :


/home/nazwausera/.mplayer

Gdzie nazwausera to : nazwa użytkownika na którym pracujesz. Tworzymy katalog fonts :


mkdir /home/nazwausera/.mplayer/fonts

Kopiujemy do nowo stworzonego katalogu ściągnięty uprzednio plik subfont.ttf. Teraz zajmiemy się plikiem iso-8859-2-win-1250.zip . Rozpakowujemy go najpierw gdziekolwiek.W rozpakowanym katalogu znajdziemy takie podkatalogi jak :

font-arial-##-iso-8859-2

gdzie ## to wielkość czcionki jaką chcemy mieć (w moim przypadku wybrałem wielkość 24).

Kopiujemy całą zawartość wybranego katalogu (w moim przypadku font-arial-24-iso-8859-2) do katalogu


/home/nazwausera/.mplayer/fonts

3.Już jesteśmy blisko.

Odpalamy mplayera i ustawiamy odpowiednio w opcjach:

Zakładka “Napisy i OSD” -> Kodowanie -> CP1250

Zakładka “Czcionka” -> Kodowanie -> Unicode

Zakładka “Czcionka” -> Kodowanie -> u samej góry jest miejsce na ścieżkę do czcionki -> wpisujemy ścieżkę do naszego subfont.ttf czyli :

/home/nazwausera/.mplayer/fonts/subfont.ttf

4.Klikamy OK i wychodzimy z Mplayera

Przy kolejnym uruchomieniu cieszymy się polskimi fontami w podpisach filmów

MySQL data in /home direcotory

2008-12-28T19:24:00.002+01:00

(following http://www.debianadmin.com/mysql-database-server-installation-and-configuration-in-ubuntu.html)

Here is the procedure how to change Mysql default data directory

By default, MySQL’s datadir is placed in the /var/lib/mysql directory.

Create the directory that will be new datadir (ex:-/home/db)

chown the directory to the mysql:mysql user

sudo chown -R mysql:mysql /home/db/*

You need to stop the mysql server using the following command

sudo /etc/init.d/mysql stop

Now you need to edit the /etc/mysql/my.cnf file

sudo vi /etc/mysql/my.cnf

and look for “datadir = /var/lib/mysql” this si where mysql database default data directory here you need to change this one to your new directory

datadir = /home/db

copy the files from the old datadir to the new location. However, make sure that the files named
ib_arch_log_0000000000, ib_logfile0 etc. are not copied to the newer location.

Make sure that the files and directories are owned by mysql user

Make changes in the my.cnf to point the new datadir.

Restart the MySQL database

sudo /etc/init.d/mysql start

----

Following: http://neodon.blogspot.com/2008/09/changing-data-directory-for-mysql-in.html

You simply edit /etc/apparmor.d/usr.sbin.mysqld. Underneath the two lines authorizing the default MySQL data directories, add two more with your custom directory. Make sure you have a trailing / on the directory name, otherwise it will not work (I had this problem at first). After this change, restart AppArmor:

sudo invoke-rc.d apparmor restart

Now you should be able to set up the new directory as a MySQL data directory and initialize it using mysql_install_db. For more information on this topic, check out the following links:

Wyświetlanie Daty

2008-12-04T02:26:00.002+01:00


strftime:

  %a - The abbreviated weekday name (``Sun'')
  %A - The  full  weekday  name (``Sunday'')
  %b - The abbreviated month name (``Jan'')
  %B - The  full  month  name (``January'')
  %c - The preferred local date and time representation
  %d - Day of the month (01..31)
  %H - Hour of the day, 24-hour clock (00..23)
  %I - Hour of the day, 12-hour clock (01..12)
  %j - Day of the year (001..366)
  %m - Month of the year (01..12)
  %M - Minute of the hour (00..59)
  %p - Meridian indicator (``AM''  or  ``PM'')
  %S - Second of the minute (00..60)
  %U - Week  number  of the current year,
          starting with the first Sunday as the first
          day of the first week (00..53)
  %W - Week  number  of the current year,
          starting with the first Monday as the first
          day of the first week (00..53)
  %w - Day of the week (Sunday is 0, 0..6)
  %x - Preferred representation for the date alone, no time
  %X - Preferred representation for the time alone, no date
  %y - Year without a century (00..99)
  %Y - Year with century
  %Z - Time zone name
  %% - Literal ``%'' character

   t = Time.now
   t.strftime("Printed on %m/%d/%Y")   #=> "Printed on 04/09/2003"
   t.strftime("at %I:%M%p")            #=> "at 08:56AM"

Netbeans 6.5, a GIT

2008-11-22T01:37:00.005+01:00

W przypadku nowej wersji Netbeansa, szczególnie dla developerów Ruby on Rails uciążliwy może być brak wsparcia dla systemu wersjonowania GIT. Na szczęście dostępny jest już odpowiedni moduł (na razie w wersji eksperymentalnej), który doda do naszego środowiska odpowiednie wsparcie. Zainteresowanych odsyłam na oficjalną stronę.

NetBeans 6.5

2008-11-20T18:53:00.005+01:00

Właśnie ukazał się nowy NetBeans 6.5. Od dłuższego czasu używam tego środowiska do pisania aplikacji w Ruby on Rails i śmiało mogę go polecić wszystkim, którzy szykają edytora wspirającego w "rozsądny sposób podpowiadanie składni". Bardzo ciekawą cechą podpowiedzi kodu w NetBeansie jest wyświetlanie również odpowiedniego fragmentu RDoca, co umożliwia szybki dostęp do bardzo wielu przykładów użycia danych metod (bardzo cenne zwkłaszcza dla metod ActiveResource).

Zainteresowanych odsyłam również na stronę Huukau, gdzie znajduje się bardzo dobry schemat graficzny dla developerów rubiego.

Alternatywny temat kolorystyczny znaleźć możemy również na stronie Tora Norbyesa

Na zakończenie ostatni ciekawy temat kolorystyczny, który znaleźć możemy na stronie iBrasten.

Ubuntu 8.10 Sun Java 1.6

2008-11-03T23:15:00.001+01:00

Instalacja:


 sudo apt-get install sun-java6-jdk
 sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-6-sun/jre/bin/java 1100

RubyGems 1.3.1 na Ubuntu 8.10

2008-11-03T21:00:00.003+01:00

Wraz z pojawieniem się nowej wersji Ubuntu 8.10 - nie obeszło się bez problemów. Domyślnie dla tej wersji apt-get instaluje rubygemy w wersji 1.2. Niestety polecenie:


sudo update_rubygems

Wydane po instalacji "gem install rubygems-update" się nie wywołuje.

Oto metoda jak sobie z tym poradzić znaleziona na blogu (http://roninonrails.blogspot.com/2008/11/setting-up-ubuntu-810-for-ruby-on-rails.html):


wget http://rubyforge.org/frs/download.php/45905/rubygems-1.3.1.tgz
cd rubygems-1.3.1
ruby setup.rb
ln -s /usr/bin/gem1.8 /usr/bin/gem

Ruby on Rails pod maską Ogólnopolskiej Informacji Medycznej

2008-10-16T03:10:00.004+02:00

Firma Delta Software oficjalnie uruchomiła serwis Ogólnopolskiej Informacji Medycznej. Cały projekt zrealizowany został w technologii Ruby on Rails. Technologia ta umożliwiła wytworzenie produktu, który stać się ma największą konkurencją dla dotychczasowych portali medycznych. W chwili obecnej system działa w podstawowej funkcjonalności, jednakże bardzo szybko uruchamiane są dodatkowe moduły. W ostatecznej wersji serwis wykorzystywać będzie również algorytmy sztucznej inteligencji.

Instalacja Ruby on Rails 2.1 pod Ubuntu 8.04

2008-07-10T02:58:00.010+02:00

Informacje zaczerpnięte są ze strony "Installing Ruby & Rails on Ubuntu 8.04 Hardy Heron", ale jednocześnie starałem się je uzupełnić o rozwiązania problemów na jakie można trafić w trakcie instalacji (dodane elementy starałem się wyróżniać kolorem czerwonym).

Krok 1:
Instalacja pakietów podstawowych


sudo apt-get install ruby irb ri rdoc ruby1.8-dev 
libzlib-ruby libyaml-ruby libreadline-ruby libncurses-ruby libcurses-ruby libruby 
libruby-extras libfcgi-ruby1.8 build-essential libopenssl-ruby libdbm-ruby libdbi-ruby 
libdbd-sqlite3-ruby sqlite3 libsqlite3-dev libsqlite3-ruby libxml-ruby libxml2-dev 
ruby rubygems

Krok 2:
Instalacja najnowszej wersji gem


sudo gem update --system

Może się zdażyć, że pojawi się komunikat następującej treści:


uninitialized constant Gem::GemRunner

Rozwiązanie można znaleźć na tej stronie, ale ponieważ jest krótkie pozwoliłem sobie je zamieścić poniżej:


sudo gedit /usr/bin/gem

A następnie przed linią:


require 'rubygems'

Dodajemy:


require 'rubygems/gem_runner'

3. Krok
Dalsza aktualizacja gema:


gem install rubygems-update
sudo update_rubygems

4. Krok
Instalacja railsa


sudo gem install rails

To zainstaluje nam najnowszą wersję railsa. Gdybyśmy chcieli zainstalować również wcześniejszą wersję należy wywołać następującą komendę (zainstaluje ona railsa w wersji 2.0.2)


sudo gem install rails -v 2.0.2

5. Krok
Instalacja bazy danych i narzędzi pomocniczych


sudo apt-get install mysql-server mysql-client libdbd-mysql-ruby mysql-query-browser mysql-admin

6. Krok
Instalacja gema mysql


sudo gem install mysql

W przypadku problemów z isntalacją warto przeczytać tego posta.

6. Krok
Instalacja dodatkowych przydatnych gemow:


sudo gem install mongrel sqlite3-ruby capistrano mini_magick mislav-will_paginate

Instalacja gema mysql pod ubuntu

2008-07-08T15:12:00.006+02:00

Jeżeli w czasie wywołania:


sudo gem install mysql

Pojawia się następujący błąd:


/usr/bin/ruby1.8 extconf.rb install mysql
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lm... yes
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lz... yes
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lsocket... no
checking for mysql_query() in -lmysqlclient... no
checking for main() in -lnsl... yes
checking for mysql_query() in -lmysqlclient... no
*** extconf.rb failed ***

Należy zainstalować następującą bibliotekę:


sudo apt-get install libmysqlclient15-dev

A następnie wywołać:


sudo gem install mysql

Drag&Drop dla drzewa

2008-07-03T23:24:00.006+02:00

Jeżeli w projekcie nad którym pracujemy potrzebna jest funkcjonalność zapewniająca sortowanie listy możemy wykorzystać dwie rzeczy - ScriptAculoUs(domyślnie dostarczona wraz z railsem) oraz ActsAsList.

Problem stanowiło natomiast utworzenie sortowalnego drzewa. Z pomocą w tym przypadku przychodzi rozwiązanie opracowane przez Svena Fuchsa.

Poniżej przykładowe dwa dema:
demo/bold.html
demo/textmate.html

Migracje w rails 2.1

2008-06-27T13:14:00.007+02:00

W nowym wydaniu Railsa w wersji 2.1 w nasze ręce oddana została poprawiona funkcjonalność związana z zarządzaniem migracjami. Poprawione zostały dwie rzeczy. Pierwsza dotyczy generowania samych migracji, które przestały być już oznaczane kolejnymi numerami wersji (stanowiło to czasami nie lada wyzwanie kiedy w projekcie kilka osób jednocześnie pracowało z modelem), a druga możliwości określania zmian w tabelach.

Od wersji rails 2.1 migracje numerowane są tak zwanym stemplem czasowym. W praktyce oznacza to, że wygenerowanie migracji za pomocą script/generate migration nowa_migracja spowoduje utworzenie pliku o nazwie zbliżonej do tej: 20080627102918_nowa_migracja.rb

Wcześniej jeżeli dwie osoby jednocześnie wygenerowały migracje trzeba było cofać wprowadzone zmiany (najlepiej przed pobraniem zmian z SVNa - ponieważ tylko wtedy odbywało się to w miarę bezproblemowo), zmieniać nazwy plików i dopiero wówczas migrować model. Teraz proces ten przeprowadzany jest automatycznie. W momencie w którym rake db:migrate stwierdzi, że w katalogu znajdują się migracje z wcześniejszym stemplem czasowym, cofa wszystkie zmiany, a następnie migruje model z uwzględnieniem wcześniejszej migracji.

Druga zmiana w Railsie 2.1 dotyczy sposobu w jaki możemy definiować zmiany tabel przyjrzyjmy się poniższemu fragmentowi kodu:


change_table :news do |:tabela| 
  tabela.belongs_to :issue # Doda kolumnę issue_id
  tabela.string :naglowek, :autor # Doda dwie kolumny typu string
  tabela.remove :header, :author #Usunie dwie kolumny
end

Do dyspozycji mamy teraz następujace modyfikatory dostępne w bloku kodu metody change_table:

tabela.index - dodaje indeks

tabela.change - zmienia definicję kolumny np. tabela.change :nazwa, :string, :limit => 200

tabela.change_default - zmienia wartość domyślną dla kolumny

tabela.rename - zmienia nazwę kolumny

tabela.remove - usuwa kolumnę

tabela.remove_belongs_to - usuwa kolumnę z kluczem obcym

tabela.remove_timestams - stemple czasowe

dodatkowo możemy używać (references, string, text, integer, float, decimal, datetime, timestamps, time, date, binary, boolean)

Błąd: no such file to load -- mkmf

2008-06-27T11:27:00.003+02:00

W przypadku kiedy chcemy zainstalować Mongrela, a pojawia się nam poniższy błąd:


Building native extensions.  This could take a while...
ERROR:  Error installing mongrel:
 ERROR: Failed to build gem native extension.

/usr/bin/ruby1.8 extconf.rb install mongrel
extconf.rb:1:in `require': no such file to load -- mkmf (LoadError)
 from extconf.rb:1

należy zainstalować developerską wersję ruby


 sudo apt-get install ruby1.8-dev

To powinno rozwiązać problem.

Problem z zależnościami rubygems w ubuntu 8.04

2008-06-27T11:07:00.004+02:00

Korzystając z nowego railsa 2.1 w ubuntu 8.04 możemy natknąć się na następujący problem


/usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/locator.rb:91:in `add': wrong number of arguments (2 for 1) (ArgumentError)
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/locator.rb:91:in `plugins'
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/loader.rb:63:in `locate_plugins'
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/loader.rb:62:in `map'
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/loader.rb:62:in `locate_plugins'
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/loader.rb:27:in `all_plugins'
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/loader.rb:22:in `plugins'
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/rails/plugin/loader.rb:45:in `add_plugin_load_paths'
 from /usr/lib/ruby/gems/1.8/gems/rails-2.1.0/lib/initializer.rb:235:in `add_plugin_load_paths'

Występuje on w momencie kiedy dodamy do pliku konfiguracyjnego informację wiążącą naszą aplikację z konkretnymi gemami (i to o dziwo nie wszystkimi bo will_paginate działa prawidłowo) np.:


 config.gem 'mini_magick', :version => '~>1.2.3'

Googlując za rozwiązaniem udało mi się znaleźć witrynę http://rails.lighthouseapp.com/projects/8994/tickets/293-gem-dependencies-broken-in-2-1-0, gdzie z opisu w kolejnych postach można wywnioskować, że usunięcie pakietu rubygems i zainstalowanie go ze źródeł powinno pomóc. Niestety w moim przypadku nie dało to oczekiwanego rezultatu.

Ściągawki dla programistów ruby on rails

2008-06-26T14:44:00.002+02:00

Natknąłem się dzisiaj na bardzo ciekawy, a zarazem szeroki zbiór krótkich ściągawek dla programistów ruby on railsa.

Warte polecenia:

http://radarek.jogger.pl/2008/03/12/zestaw-ponad-40-sciagawek-dla-programistow-ruby-on-rails-i-n/

Paginacja w rails 2.1 (gem will_paginate)

2008-06-26T13:51:00.010+02:00

W railsie 2.0.2 do paginacji można było używać will_paginate instalowanego jako plugin. Po przejściu do railsa 2.1 okazało się, że widoki zawierające paginatory przestały działać. Nie będę opisywał tutaj walki z usunięciem tego błędu - bo skutkowała wieloma mało zrozumiałymi komunikatami.

Aby wykorzystać paginacje w railsie 2.1 należy:

usunąć katalog will_paginate z /vendor/plugins/

do pliku environment.rb dodać nastepującą linijkę:
```
config.gem 'mislav-will_paginate', 
    :version => '~> 2.3.2', 
    :lib => 'will_paginate', 
    :source => 'http://gems.github.com'
```
Uwaga:na sieci znalazłem kilka wersji sposobu dodania will_paginate do environment.rb - niestety nie wszystie chciały działać!

Na końcu pliku environment.rb należy dopisać (za słowem kluczowym end):
```
require 'will_paginate'
```

wywołać task raka:
```
sudo rake gems:install
```
Uwaga: instalacja gemów wymaga uprawnień administratora

Teraz możemy cieszyć się prawidłowo działającą aplikacją.

Różnica pomiędzy count, length a size

2008-06-26T10:15:00.009+02:00

W ruby on rails mamy do dyspozycji trzy metody określające ilość elementów w kolekcji - length, count, size. Aby zoptymalizować działanie naszej aplikacji warto jednak wiedzieć w jaki sposób działa każda z nich:

length (np. obiekt.kolekcja.length) - pobiera całą kolekcje, a nastepnie zwraca liczbę elementów

count (np. obiekt.kolekcja.count) - zwraca liczbę elementów nie pobierając kolekcji do pamięci (wykorzystuje SQLową instrukcję count)

size (np. obiekt.kolekcja.size) - metoda ta jest połączeniem działania dwóch poprzednich metod. Jeżeli obiekt.kolekcja został wcześniej pobrany to działanie jest podobne do instrukcji length, jeżeli natomiast kolekcja nie została pobrana wywołana zostanie instrukcja count

Mam nadzieję, że to krótkie wyjaśnienie pozwoli zrozumieć różnicę pomiędzy tymi trzema instrukcjami i jednocześnie pozwoli tworzyć bardziej efektywny kod.

Ukryte Modele Markowa w rozpoznawaniu mowy

2008-06-24T16:06:00.007+02:00

Ukryte modele Markowa jako metoda rozpoznawania mowy

Publish at Scribd or explore others: Research ukryte łańcuchy mark łańcuchy markowa

Programowanie gier, modyfikacje alfa-beta obcięcia oraz heurystyki funkcji oceniających.

2008-06-24T15:09:00.004+02:00

Pełna wersja dokumentu dostępna pod adresem: http://www.deltasoftware.pl/dokumenty/Michal_Stanek-Sztuczna_inteligencja_w_grach.pdf

Wstęp

Gwałtowny rozwój komputerów w drugiej połowie ubiegłego wieku przyczynił się do znacznego postępu zarówno w nauce jak i przemyśle. Dały one możliwość realizacji rzeczy które wcześniej można było analizować jedynie teoretycznie. W głowie nie jednego naukowca zrodziło się wówczas pytanie, czy maszyna będzie w stanie dorównać kiedyś możliwością człowieka?
Zaczęła rozwijać się dynamicznie dziedzina zwana sztuczną inteligencją. Zadawano sobie pytanie w jaki sposób mierzyć zdolności maszyny? Dylemat ten rozwiązał Alan Turing konstruując słynny test Turinga. Test ten odnosi się jednak tylko do zdolności językowych. Sam Alan Turing a nawet Shannon rozważał rozszerzenie tego testu o przeprowadzenie rozgrywki w szachy, od wieków bowiem gra ta była uznawana za królową wszystkich gier. Turing stwierdził nawet w jednej ze swoich wypowiedzi z 1951 roku, że nikt nie jest w stanie napisać programu, który gra lepiej od niego samego. Mimo niezaprzeczalnie wielkiego geniuszu w tej kwestii się pomylił.

Mimo że nie ujęta w teście Turinga gra w szachy przez wielu uważana była za wyznacznik zdolności maszyny do myślenia. Określała granicę pomiędzy możliwościami ludzkiego umysłu a maszyną. Ostatecznie po 45 latach prób, zaczynając od roku 1952, kiedy to powstał pierwszy program A. Sammuela, maszyna pokonała szachowego mistrza świata.

Nie tylko szachy wzbudzały zainteresowanie uczonych. Badania i eksperymenty prowadzone były dla bardzo wielu popularnych gier, wśród nich othello, go warcaby. W wielu z nich ostateczny sukces, to znaczy zwycięstwo nad człowiekiem został osiągnięty dużo wcześniej niż w szachach. Przykładowo problem gry w warcaby uważa się obecnie za praktycznie rozstrzygnięty. Oznacza to, że w zdecydowanej większości przypadków jesteśmy w stanie określić wynik gry już po wykonaniu kilku pierwszych ruchów.

Gra, strategia i drzewo gry

Według definicji Von Noumana i Morgensterna gra to składa się z zestawu reguł określających możliwości wyboru postępowania jednostek znajdujących się w sytuacji określanej mianem konfliktu interesów. Każda z tych jednostek stara się maksymalizować swój własny zysk i jednocześnie zminimalizować zysk pozostałych graczy. Reguły gry określają też ilość informacji dostępną każdemu z graczy oraz wysokość wygranych i przegranych.

W ogólności grę można rozumieć jako rozgrywkę prowadzoną przez gracza lub graczy, zgodnie z ustalonymi zasadami gry, w celu osiągnięcia ściśle zdefiniowanego celu.

Należałoby również zdefiniować pojęcie równie ważne - strategia gry, pod którym rozumieć będziemy kompletny zbiór zasad, które determinują posunięcia gracza, wybierane zależnie od sytuacji powstających podczas gry.

Gry można podzielić również na kilka kategorii w zależności od charakterystycznych cech.

Ze względu na ilość graczy:

Gry bezosobowe (np. Gra w życie)

Gry jednoosobowe (puzzle, pasjans)

Gry dwuosobowe (szachy, warcaby, otello, go)

Gry wieloosobowe (poker, brydż)

Wygrana i przegrana:

Gry o sumie zerowej (wygrana jednego gracza oznacza przegraną drugiego gracza) – szachy, warcaby, otello

Gry o sumie nie zerowej – np. Dylemat więźnia

Współpraca graczy:

Kooperacyjne (gracze współpracują ze sobą)

Niekooperacyjne (gracze nie współpracują ze sobą)

Występowanie w grze elementu losowości:

ałkowicie losowe (ruletka)

Częściowo losowe (brydż i inne gry karciane)

Całkowicie deterministyczne (warcaby, szachy, otello, go)

To czym jest gra można wyrazić również pewnym równaniem:

Gra = cel + stan początkowy + operatory

Gdzie pod pojęciem operatora rozumieć możemy stosowanie reguł gry. Działanie operatora nie musi być deterministyczne – może go określać np. rozkład zmiennej losowej, w grach częściowo losowych takich np. brydż. Każdy operator może posiadać również koszt związany z jego zastosowaniem. Należy podkreślić, że w grze dwuosobowej mamy wpływ na wybór tylko połowy operatorów.
Rozpoczęcie gry ze stanu początkowego, a następnie stosowanie możliwych operatorów prowadzi do zbudowania tak zwanego drzewa gry, którego reprezentacja przedstawiona jest na rysunku 1(rysunek dostępny w dokumencie pdf).

Algorytm Min-Max

Jednym z większych osiągnięć w teorii gier było opracowanie algorytmu min-max[KNU75]. Zasada jego działania opiera się na prostym spostrzeżeniu, że podczas gry każda ze stron stara się maksymalizować swoje zyski, przy jednoczesnej minimalizacji zysków przeciwnika1(podejście takie można zauważyć już w definicji Von Noumana i Morgensterna).

Zakładając że możemy oszacować stan gry w każdym momencie z dość dużym przybliżeniem, jesteśmy w stanie przewidzieć, które ruchy przybliżą nas do wygranej, a które nie. Oczywiście im głębiej będziemy analizować drzewo gry, tym lepiej można wybrać operatory, które prowadzą nas do wygranej. W ekstremalnym przypadku, gdy jesteśmy w stanie rozwinąć całe drzewo gry jednoznacznie możemy wybrać posunięcia prowadzące nas do wygranej. Algorytm min-max został opracowany i opublikowany przez Knutha i Moore'a w 1975 r. Stanowi on fundament działania wielu innych algorytmów. Ilustracja działania algorytmu min-max przedstawiona jest na rysunku 2 (dostępny w wersji pdf dokumentu).

Na jakość gry przy wykorzystaniu algorytmu min-max wpływają z jednej strony głębokość przeszukiwania z drugiej jakość funkcji heurystycznej. Nie da się osiągnąć zadowalających wyników jeżeli którykolwiek z tych elementów jest źle dobrany.

Algorytm min-max przyczynił się do powstania algorytmu alfa-beta obcięcia, którego działanie polega na ograniczeniu ilości rozwijanych wierzchołków drzewa gry. Dokładne opisy algorytmu Alfa-Beta obcięcia można znaleźć w pracy [KWA04].

Konstrukcja funkcji heurystycznej

Jak wspomniano we wcześniejszym rozdziale na jakość działania algorytmy alfa-beta obcięcia zasadniczy wpływ ma stworzenie odpowiedniej funkcji oceniającej. Funkcja oceniająca jest funkcją heurystyczną1, to znaczy konstruowaną w założeniu, że pewne stany gry są lepsze lub gorsze od innych. Funkcja heurystyczna zazwyczaj przyjmuje postać wielomianu postaci:

F(s) = w1 * x1 + ... + wn * xn,

gdzie:
s - to pewien stan gry, który chcemy ocenić,
x1 - do xn to pewne cechy (np. ilość pionków na planszy, zajmowanie pewnych pól szachownicy),
w1 - do wn są wagami z jakimi brana jest pod uwagę wartość pewnej cechy.

Konstrukcja funkcji heurystycznej, to znaczy dobór odpowiednich parametrów oraz ich wag, zależy zazwyczaj od projektanta (programisty). Z jednej strony podejście takie jest dobre, ponieważ pozwala podzielić problem na dwa mniejsze:

wyboru cech branych pod uwagę,

doboru wagi każdej z wcześniej wybranych cech.

Z drugiej natomiast pozostawia pewien element subiektywności osobie, która konstruuje taką funkcję.

GLEM – ogólny liniowy model oceniania

W odpowiedzi na problemy związane z konstrukcją heurystycznych funkcji oceniających powstał GLEM (Generalized Linear Evaluation Model). Ideą jaka przyświecała jego powstaniu była chęć stworzenia standardowego sposobu rozwiązywania klasy problemów cechujących się tym, że funkcję heurystyczną można przedstawić jako kombinację liniową dostatecznej ilości cech [BURO02]. GLEM nie zwalnia nas co prawda z obowiązku wyboru cech podstawowych, przez autorów artykułu nazwanych atomowymi. Nadal zmuszeni jesteśmy określić jakie elementy mają być brane pod uwagę. Przez cechy atomowe rozumiemy tutaj na przykład cechy takie jak obecność konkretnego pionka na konkretnym polu planszy, posiadanie konkretnej karty itp. Resztę parametrów to znaczy wartości wag z jakimi cechy te będą brane pod uwagę dobierane są przez algorytm automatycznie na podstawie dostarczonych przykładów uczących.

.... dalsza część artykułu dostępna w wersji PDF

Wzorce projektowe warsty prezentacji

2008-06-24T14:01:00.042+02:00

Dokument w wersji PDF można pobrać z tego miejsca http://www.deltasoftware.pl/dokumenty/Michal_Stanek-Wzorce_Projektowe.pdf

Wstęp

Wzorce projektowe są ogólnymi rozwiązaniami popularnych problemów, jakie pojawiają się podczas projektowania systemów informatycznych. Użycie przetestowanych i efektywnych rozwiązań pozwala zminimalizować koszty oraz skrócić czas potrzebny do wytworzenia oprogramowania. Polepszeniu ulega także komunikacja między ekspertami i zespołami projektowymi.

Dokument ten omawia wzorce projektowe warstwy prezentacji, na przykładzie platformy J2EE. Po wstępnym omówieniu problemów związanych z tworzeniem nowoczesnych aplikacji biznesu elektronicznego, przedstawione zostały trzy wzorce projektowe warstwy prezentacji: Intercepting Filter, Context Object, Composite View. Każdy wzorzec został ogólnie omówiony, przedstawiono diagramy klas oraz sekwencji, przedstawiono również przykładowe strategie implementacji.

Projektowanie aplikacji J2EE

Specyfikacja J2EE powstała z myślą o zaspokojeniu potrzeb developerów aplikacji biznesu elektronicznego. Zawiera ona takie składowe jak strony JSP, komponenty JSP, usługi nazw jak JNDI, i wiele innych. Każdy z tych składników w mniejszym lub większym stopniu zaspokaja potrzeby

EJB - Reprezentuje komponent Enterprise Java Bean, związany jest z reguły z obiektem biznesowym. Rolę tę pełni zazwyczaj komponent sesyjny lub Entity.

JSP - Java Server Pages. Technologia związana z generowanie widoku za pomocą osadzenia kody Javy na stronie HTML. Kod Javy zawarty jest w specjalnych znacznikach, a sama strona JSP wykonywana jest przez serwer servletów.

Trzeba zdawać sobie sprawę z tego, że wiele, a można byłoby zaryzykować twierdzenie, że większość dzisiejszych aplikacji biznesu elektronicznego wykorzystuje możliwości, jakie dają sieci komputerowe. Projektanci stają wobec tego przed zupełnie nowymi wyzwaniami, wśród których wyróżnić można aspekt związany z rozproszeniem, dostępnością, bezpieczeństwem itp. Tym własnie wyzwanią stawiają czoła wzorce projektowe opracowane dla platformy J2EE przez konsorcjum Sun Java Center. Niniejszy dokument skupi sie na omówieniu trzech wzorców warstwy prezentacji.

Wzorce projektowe w J2EE

Poprawionym aspektem przyszłej pielęgnacji aplikacji.

Lepszą modułowością.

Możliwością rozdzielenia ról członków zespołu projektowo-programistycznego.

Poprawieniem bezpieczeństwa dostępu.

Redukcją intensywności komunikacji sieciowej.

Zminimalizowanym kosztem wytworzenia.

Podczas projektowania systemów J2EE, często napotykamy podobne problemy. Warto przyjrzeć się kilku z nim, aby zrozumieć jak wielką rolę odgrywają dzisiaj wzorce projektowe.

Często zdarza się, że niedoświadczony programista zawiera na stronie JSP kod odpowiedzialny za wygląd (HTML), logikę biznesową(Java) oraz dostęp do bazy danych(SQL). Wprowadzenie modułu sterującego pozwoliłoby uzyskać rozwiązanie zdecydowanie lepsze. Poprawiona zostałaby modułowość, jak również przyszła możliwość modyfikacji tak utworzonego kodu.

Równie istotnym zagadnieniem jest wydzielenie kodu odpowiedzialnego za logikę biznesową z elementu odpowiedzialnego za przygotowanie widoku. Ponieważ strony JSP pozwalają umieszczać w ich wnętrzu kod Javy, programiści bardzo często umieszczają w nich typowe akcje związane z logiką biznesową. Są one niezależne i niezwiązane z formą ich prezentacji i powinny zostać wydzielone do oddzielnych klas np. Enterprise JavaBeans.

Podobnym problemem związanym ze stronami JSP, jest umieszczenie w nich kodu odpowiedzialnego za przygotowanie oraz konwersję danych. Stwarza to kłopoty związane z redundancją kodu. Rozwiązaniem tego problemu, tak jak poprzednio jest wydzielenie kodu konwersji do oddzielnych klas.

Programiści aplikacji internetowych napotykają również często na dwa inne problemy. Pierwszy z nich związany jest z odpowiednim ukrywaniem zasobów przed klientem, który najpierw powinien spełnić pewne warunki, np. przejść poprawnie proces logowania do systemu.

Drugi problem związany jest ze specyfikacją protokołu http, a dokładniej ze sposobem komunikacji przeglądarki z serwerem. Często zdarza się, że żądanie wykonania pewnej akcji zostaje powielone. W przypadku kiedy taka akcja powoduje modyfikacje danych, należy wyeliminować takie żądanie. Rozwiązaniem tych problemów może być wprowadzenie modułu sterującego takiego jak front controller [ALUR2004].

Doświadczony programista zdaje sobie również sprawę z faktu, że uzależnienie aplikacji od protokołu, w jakim pracuje, znacznie ogranicza jej późniejszy rozwój. W obecnych czasach, wraz z bardzo dynamicznych rozwojem urządzeń mobilnych jest to szczególnie istotne, aby aplikacja mogła pracować w wielu różnych środowiskach, a komunikacja z nią byłą możliwa za pomocą dowolnej ilości protokołów. Wzorzec projektowy o nazwie Context Object, stanowi rozwiązanie tego problemu.

Jest to tylko kilka problemów, z jakimi możemy spotkać się projektując aplikację sieci WWW pracującą nie tylko w technologii J2EE. Warto zaznajomić się jednak ze wszystkimi wzorcami projektowymi, gdyż wielu przypadkach nie musimy wynajdywać tak zwanego "koła" od nowa, a wypracowane przez społeczność programistów rozwiązania wielokrotnie zaspokajają wszystkie nasze potrzeby. W kolejnej części tego dokumentu omówię dokładniej trzy spośród wielu istniejących wzorców.

Wzorce projektowe J2EE warstwy prezentacji

Intercepting Filter

Często możemy spotkać się z sytuacją, w której przed przystąpieniem do właściwego przetwarzania żądania strony JSP, musimy wstępnie przetworzyć dane. Operacja ta może być przykładowo związana z przetworzeniem kodowania parametrów żądania klienta. Nie trudno sobie wyobrazić, że taka konwersja musi się pojawić na każdej stronie, która w jakikolwiek sposób wykorzystuje parametry żądania klienta. Interesuje nas wobec tego rozwiązanie, którego nie będzie trzeba integrować z głównym przetwarzaniem. Wzorzec Intercepting Filter powinniśmy stosować właśnie wtedy, gdy chcemy przechwycić i modyfikować żądanie i odpowiedź przed i po właściwym przetwarzaniu. Ogólny schemat ideowy tego rozwiązania znajduje się na poniższym rysunku:

Intercepting Filter najczęściej stosowany jest do:

Sprawdzenie, czy z klientem związana jest poprawna sesja.

Sprawdzenie, czy obsługiwany jest dany rodzaj przeglądarki.

Sprawdzenie, jakiego kodowania używa klient do wysyłania danych oraz konwersja tych danych.

Deszyfrowanie lub dekompresja strumienia danych.Sprawdzenie, czy z klientem związana jest poprawna sesja.

Sprawdzenie, czy obsługiwany jest dany rodzaj przeglądarki.

Sprawdzenie, jakiego kodowania używa klient do wysyłania danych oraz konwersja tych danych.

Deszyfrowanie lub dekompresja strumienia danych.

Typowym rozwiązaniem tego typu problemów jest umieszczenie szeregu zagnieżdżonych instrukcji if-then-else. Ponieważ jednak kod taki trzeba umieścić w każdym elemencie naszej aplikacji uzyskujemy bardzo dużą redundancję kodu. Naszym celem jest więc zastosowanie rozwiązania charakteryzującego się następującymi właściwościami.

Będzie stanowić scentralizowane, wspólne przetwarzanie dla wszystkich żądań (np. sprawdzanie kodowania).

Nie będzie mocno związane z kodem przetwarzania zasadniczego.

Będzie umożliwiać stosowanie niezależnych komponentów, które w łątwy sposób mogą być dodawane przed lub po zasadniczym przetwarzaniu.

Na dwóch poniższych rysunkach przedstawione zostały diagramy klas oraz diagramy sekwencji wzorca Intercepting Filter.

Opis poszczególnych elementów wzorca:

FilterManager - jest menadżerem filtrów. Jego zadaniem jest tworzenie obiektu FilterChain oraz ustawienie odpowiedniej sekwencji wywoływanych filtrów. FilterManager może być konfigurowalny za pomocą zewnętrznego pliku konfiguracyjnego, który określa w jakiej kolejności i jakie filtry zostaną wywołane.
FilterChain - stanowi uporządkowany zbiór niezależnych od siebie filtrów. FilterChain odpowiedzialny jest również za koordynowanie wywołań poszczególnych filtrów.

Filter - reprezentuje niezależny filtr.

Target - stanowi zasób żądania.

Najczęstszą implementacją wzorca Intercepting Filter jest wykorzystanie strategii filtru standardowego [ALUR2004]. Strategia ta zakłada wykorzystanie standardowego mechanizmu tworzenia łańcuchów filtrów, zdefiniowanego w specyfikacji serwletów w wersji 2.3. Filtry tak utworzone bazują na standardowym interfejsie javax.servlet.Filter i są luźno powiązane ze sobą oraz docelowymi zasobami. Kontrola tak utworzonych filtrów odbywa się w sposób deklaratywny, za pomocą deskryptora wdrożenia.

Zastosowanie takiego podejścia pozawala nam uzyskać rozwiązanie uniwersalne, w którym każdy filtr stanowi niezależny komponent. W przyszłości istnieje możliwość ponownego wykorzystania tak przygotowanych filtrów, lub też użycia filtrów dostarczonych przez innych. Deklaratywny sposób zarządzania filtrami za pomocą deskryptora wdrożenia umożliwia napisanie aplikacji, która nieświadoma jest obecności filtrów. W żaden sposób nie są one, ani zarządzanie nimi związane z zasadniczym kodem przetwarzania. Jako przykład takiego rozwiązania przedstawię filtr, zajmujący się konwersją kodowania różnego rodzaju kodowań formularzy stron WWW. Przedstawiany kod będzie przykładem wykorzystania wzorca Intercepting Filter do implementacji wzorca o nazwie Łańcuch odpowiedzialności. Struktura klas przykładu przedstawiona jest na poniższym rysunku.

Interceptring Filter - strategia filtru standardowego

Klasa bazowa implementująca podstawowe metody klasy Filter, z niej będą dziedziczyć klasy StandardEncodeFilter - zajmująca się przetwarzaniem formularzy standardowych (application/x-www-form-urlencoded) oraz klasa MultipartEncodeFilter - zajmująca się przetwarzaniem formularzy umożliwiających wysyłanie plików


public class BaseEncodeFilter implements javax.servlet.Filter {

  private javax.servlet.FilterConfig myFilterConfig;
  public void doFilter(javax.servlet.ServletRequest servletRequest, 
                       javax.servlet.ServletResponse servletResponse,
                       javax.servlet.FilterChain filterChain) 
                       throws java.io.IOException,
                       javax.servlet.ServletException {
    filterChain.doFilter(servletRequest, servletResponse);
}

  public javax.servlet.FilterConfig getFilterConfig() {
    return myFilterConfig; 
  }
 
  public void destroy() { }

  public void init(javax.servlet.FilterConfig filterConfig)
                   throws javax.servlet.ServletException { 
    myFilterConfig = filterConfig;
  }
}

Klasa odpowiedzialna za przetwarzanie formularzy standardowych:


public class StandardEncodeFilter extends BaseEncodeFilter {
// Tworzy nowy StandardEncodeFilter
  public StandardEncodeFilter()   {  }

  public void doFilter(javax.servlet.ServletRequest servletRequest,
                       javax.servlet.ServletResponse servletResponse,
                       javax.servlet.FilterChain filterChain) 
                       throws java.io.IOException, 
                       javax.servlet.ServletException {

    String contentType = servletRequest.getContentType();
    if ((contentType == null) || contentType.equalsIgnoreCase(
      "application/x-www-form-urlencoded")) {
      translateParamsToAttributes(servletRequest, servletResponse);
    }

    filterChain.doFilter(servletRequest, servletResponse);
  }

  private void translateParamsToAttributes(ServletRequest request,
                                           ServletResponse response) {
    Enumeration paramNames = request.getParameterNames();

    while (paramNames.hasMoreElements())     {
      String paramName = (String) paramNames.nextElement();
      String [] values;
      values = request.getParameterValues(paramName);
      if (values.length == 1)
        request.setAttribute(paramName, values[0]);
      else
        request.setAttribute(paramName, values);
    }
  }
}

Klasa odpowiedzialna za przetwarzanie formularzy umożliwiających wysyłanie plików:


public class MultipartEncodeFilter extends BaseEncodeFilter {
  public MultipartEncodeFilter() { }
  public void doFilter(javax.servlet.ServletRequest servletRequest,
                       javax.servlet.ServletResponse servletResponse,
                       javax.servlet.FilterChain filterChain)
                       throws java.io.IOException, 
                       javax.servlet.ServletException {
    String contentType = servletRequest.getContentType();   
    // Stosujemy filtr tylko dla kodowania wieloczęściowego 
   if (contentType.startsWith("multipart/form-data")){
     try {
       String uploadFolder = getFilterConfig().getInitParameter("UploadFolder");
       if (uploadFolder == null) uploadFolder = ".";
       
       MultipartRequest multi = new MultipartRequest(servletRequest, 
                                     uploadFolder,1 * 1024 * 1024 );
       Enumeration params = multi.getParameterNames();
       while (params.hasMoreElements()) {
         String name = (String)params.nextElement();
         String value = multi.getParameter(name);
         servletRequest.setAttribute(name, value);
       }
       Enumeration files = multi.getFileNames();
       while (files.hasMoreElements()) {
         String name = (String)files.nextElement();
         String filename = multi.getFilesystemName(name);
         String type = multi.getContentType(name);
         File f = multi.getFile(name);
         // W tym miejscu w razie konieczności wykonujemy coś na pliku
       }
     } catch (IOException e) {
       LogManager.logMessage("błąd odczytu lub zapisu pliku "+ e);
     }
   } // koniec if
   filterChain.doFilter(servletRequest, servletResponse);
  } // koniec metody doFilter()
}

Deskryptor wdrożenia konfigurujący zestaw filtrów:



  StandardEncodeFilter
  StandardEncodeFilter
  
   encodefilter.StandardEncodeFilter



  MultipartEncodeFilter
  MultipartEncodeFilter
  
  encodefilter.MultipartEncodeFilter
  
    UploadFolder
    /home/files
  



  StandardEncodeFilter
  /EncodeTestServlet


  MultipartEncodeFilter
  /EncodeTestServlet

Oprócz strategii filtru standardowego w literaturze [ALUR2004,Crawford] spotyka się również rozwiązania bazujące na własnej implementacji klasy FilterManager oraz klasy FilterChain. Nie są one jednak tak uniwersalne i przenośne jak przedstawiona strategia filtru standardowego, dlatego nie zostaną przeze mnie omówione.

Podsumowanie wzorca

Wykorzystanie wzorca Intercepting Filter wiąże się z pewnymi aspektami, z których projektant musi zdawać sobie sprawę. Jak zawsze są pozytywne oraz negatywne strony wykorzystania pewnych rozwiązań.

Centralizacja sterowania przy użyciu niezależnych od siebie procedur obsługi (np. autoryzacja, logowanie, szyfrowanie)

Poprawa wielokrotnego użycia

Deklaratywna i elastyczna konfiguracja

Złe strony wzorca Intercepting Filter

Mało wydajna wymiana danych pomiędzy filtrami

Context Object

Pisząc aplikacje często zdarza się, że wiążemy ją bardzo mocno z protokołem, w jakim pracuje. Bardzo częste są sytuacje, że w ramach całego programu wykorzystujemy obiekty HttpServletRequest. Poza brakiem możliwości zmiany protokołu komunikacyjnego takiego systemu, pojawia się bardzo duży problem z testowanie takiej aplikacji.

Należy używać wzorca Context Object w celu hermetyzacji stanu w sposób niezależny od protokołu i udostępniania go kolejnym elementom aplikacji. Trzy poniższe rysunki przedstawiają diagram klas i sekwencji wzorca.

Context Object diagram klas

Context Object dla protokołu HTTP

Context Object diagram sekwencji

Najczęstszą strategią implementacji wzorca Context Objet jest strategia kontekstu żądania w postaci mapy. Stan żądania jest przekształcany do postaci standardowej implementacji interfejsu Map, która jest przekazywana dalej. Zaletą tego rozwiązania jest jego prostota. Niestety jest też ujemna strona tego rozwiązania, a wiąże się ona ze słabym typowaniem parametrów przechowywanych w mapie, które są zrzutowanie na bazową klase Object. Poniżej przedstawiona jest przykładowa implementacja:


public class FrontController extends HttpServlet {
...
  private void processRequest(HttpServletRequest request,
                              HttpServletResponse response)
                              throws ServletException, java.io.IOException {

    // tworzenie obiektu RequestContext przy użyciu strategii mapy
    Map requestContextMap = new HashMap(request.getParameterMap());
    Dispatcher dispatcher = new Dispatcher(request, response);
    requestContextMap.put("dispatcher", dispatcher);

    // utworzenie instancji ApplicationController
    ApplicationController applicationController = new ApplicationControllerImpl();

    // przetwarzanie żądania
    ResponseContext responseContext =
      applicationController.handleRequest(requestContextMap);

    // przetwarzanie odpowiedzi
    applicationController.HandleResponse(requestContextMap,responseContext);
  }
  ...
}

Podsumowanie

Dobre strony wzorca \textsl{Context Object}:

Ułatwia pielęgnację i umożliwia ponowne wykorzystanie.

Ułatwia testowanie - ze względu na wykorzystanie standardowych obiektów Javy możliwe jest testowanie aplikacji za pomocą standardowych narzędzi takich jak JUnit.

Zmniejszone ograniczenia związane ze zmianą interfejsów.

Złe strony:

Zmniejszona wydajność.

Composite View

Tworzenie złożonych wizualnie stron internetowych jest skomplikowaną sprawą. W przypadku kiedy tworzymy całe serwisy, wiele stron jest do siebie podobnych, lub nawet zawiera te same elementy (fragmenty szaty graficznej, system menu, itp.). Wstawianie ich na każdą stronę z osobna sprawia, że późniejsza modyfikacja tych elementów jest niezwykle pracochłonna, lub też czasami nawet nie możliwa.

Zastosowanie wzorca Composite View umożliwia konstruowanie dokumentów stron WWW poprzez złożenie elementów składowych, np. na podstawie szablonu wyglądu. Umożliwia on wprowadzenie wspólnych nagłówków, stopek, paneli nawigacyjnych w wielu miejscach dowolnego z generowanych dokumentów. W rozwiązaniach bazujących na tym wzorcu układ dokumentu wynikowego może być konfigurowany niezależnie od prezentowanej zawartości.

Composite View umożliwia również stworzenie rozwiązania w którym w prosty sposób możemy dostosować prezentowaną informację do roli użytkownika (np. kupujący, sprzedający, administrator systemu) aktualnie przeglądającego serwis WWW. Rysunek poniżej przedstawia standardową budowę strony WWW na przykładzie serwisu www.e-informatyka.pl.

Przykładowa struktura strony WWW

Poniżej wypunktowane są kluczowe czynniki, które powinniśmy rozpatrzyć w celu podjęcia decyzji o zastosowaniu wzorca Composite View:

Potrzeba zastosowania wspólnych podwidoków (nagłówków, stopek, tabel), używanych w wielu miejscach.

Częsta konieczność zmiany wspólnych elementów wielu widoków (np. szaty graficznej).

Chęć uniknięcia powielania elementów, oraz modułowa budowa strony widoku.

Rysunek poniżej przedstawia diagram klas wzorca Composite View.

Composite View diagram klas

Opis poszczególnych elementów wzorca:

Client - wybiera widok.

View - reprezentuje wyświetlaną stronę. Każdy obiekt View, może być obiektem typu \textsl{SimpleView} albo CompositeView.
SimpleView - reprezentuje podstawowy element składowy widoku złożonego. Nazywany jest też podwidokiem lub segmentem widoku.

CompositeView - składa się z kilku obiektów typu \textsl{View}.

Template - reprezentuje szablon widoku.

ViewManager - używa obiektu \textit{Template} do utworzenia rozkładu strony, w której osadzona jest następnie odpowiednia zawartość. Umożliwia on niezależne zarządzanie zawartością i układem strony.

Composite View diagram sekwencji

Istnieje kilka strategii implementacji wzorca Composite View na platformie J2EE. Do najczęściej wykorzystywanych należą strategie zarządzania widokiem za pomocą:

komponentów Java Beans,

znaczników standardowych,

znaczników własnych,

przekształceń (np. XML + XSTL).

W strategii wykorzystującej pierwszej, komponenty Java Beans odpowiadają za generowanie poszczególnych widoków. Przykład strony wykorzystującej to rozwiązanie znajduje się poniżej.


<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
<%@ taglib uri="/web-INF/corej2eetaglibrary.tld" prefix="cjp" %>
 
<jsp:useBean id="contentFeeder"
  class="javabean.ContentFeeder" scope="request" />

<table valign="top" cellpadding="30%"  width="100%">
 
  <cjp:personalizer interest='global'>
    <tr>
      <td><b><c:out value="${contentFeeder.worldNews}"/></b></td>
    </tr>
  </cjp:personalizer>
...

Rozwiązanie wykorzystujące standardowe znaczniki JSP, jest przez wielu ekspertów [Alur2004,Crawford] uważane za bardziej "eleganckie". Związane jest to z faktem całkowitego wyeliminowania kodu Javy z głównego widoku. Taka strategia umożliwia zastosowanie podziału odpowiedzialności (ang. "separation of concern" [Sherif2000]), w którym osoba odpowiedzialna za przygotowanie szaty graficznej (np. grafik komputerowy), nie musi umieć programować a jedynie wykorzystywać elementy przygotowane przez inne osoby. Kod zamieszczony poniżej przedstawia rozwiązanie bazujące na znacznikach standardowych JSP (element jsp:include oraz @include, odpowiadają kolejno za statyczne oraz dynamiczne dołączenie zewnętrznego podwidoku).


<body>
<jsp:include page="/jsp/banner.seg" flush="true"/> 
<table>
  <tr>
    <td>
    <jsp:include page="/jsp/CompositeView/javabean/ProfilePane.jsp" 
      flush="true"/> 
    </td>
    <td>
       <td><%@ file="news/worldnews.html" %> </td>
    </tr>
...

Strategia oparta na znacznikach własnych, jest rozszerzeniem strategii poprzedniej. Znaczniki własne są potężnym mechanizmem zarządzania zawartością i układem strony. Pomimo zwiększonego nakładu pracy programistów (proces tworzenia własnych znaczników jest złożony), jest to rozwiązanie preferowane [Alur 2004]. Zamieszczony poniżej kod przedstawia sposób wykorzystania własnych znaczników w procesie przygotowania strony.


<region:render template='/jsp/CompositeView/templates/portal.jsp'>
  <region:put section='banner' content='/jsp/CompositeView/templates/banner.jsp' />
  <region:put section='controlpanel' content='/templates/ProfilePane.jsp' />
  <region:put section='mainpanel' content = '/templates/mainpanel.jsp' />
  <region:put section='footer' content='/templates/footer.jsp' />
</region:render>

trategia bazująca na przekształceniach, to z reguły rozwiązania bazujące na XML'u oraz XSLT. Jest to rozwiązanie o największych możliwościach, ale jednocześnie najmniejszej efektywności. Widok może być wielokrotnie transformowany zanim zostanie przekazany klientowi, a każda z transformat może być niezależnie wymieniana na inną. Rozwiązanie takie jest nieocenione, kiedy z naszej aplikacji korzysta wielu klientów o różnych możliwościach (np. przeglądarka internetowa, urządzenia PDA, telefony komórkowe, itp.). Powstało wiele środowisk wspierających taką strategie np. Cocoon (http://cocoon.apache.org/). Idea działąnia przekształceń została przedstawiona na poniższym rysunku.

Composite View strategia z wykorzystaniem przekształceń

Podsumowanie

Wprowadzenie wzorca \textsl{Composite View} pociąga za sobą pewne konsekwencje, z których powinniśmy zdawać sobie sprawę. Oprócz pozytywnych aspektów zastosowania tego rozwiązania istnieją również słabe strony. Do plusów niewątpliwie moglibyśmy zaliczyć:

Poprawę modularności i możliwość ponownego wykorzystania kodu.

Możliwość dodania kontroli opartej na regułach. Do takich reguł może należeć rola użytkownika lub pewne ustawienia systemowe.

Ułatwienie pielęgnacji kodu.

Istnieje jednak kilka negatywnych aspektów:

Utrudnienie zarządzania kodem. Związane to jest z możliwością powstawania błędów wyświetlania podczas łączenia kilku elementów w jednym widoku.

Zmniejszenie wydajności - związane z koniecznością dynamicznego tworzenia widoku na żądanie klienta.

Zakończenie

Dokument ten stanowi jedynie wstęp do tematyki wzorców projektowych warstwy prezentacji platformy J2EE. Pokazuje jednak jak ważną rolę mogą one odegrać w procesie projektowania aplikacji. Pozwalają zredukować koszty wytworzenia systemu, dzięki zastosowaniu sprawdzonych rozwiązań. Dzięki wzorcom możemy także efektywniej komunikować się o obrębie zespołów projektowych.

Nie należy jednak zapominać, że wzorzec projektowy stanowi jedynie szablon pewnego rozwiązania. Szablon ten następnie może być zaimplementowany za pomocą kilku strategii. Starałem się wraz z omawianiem każdego wzorca przejście od zdefiniowania problemu jaki nas dotyczy, przez wybranie ogólnego rozwiązania (wzorca projektowego), aż do jego szczegółowej implementacji będącej strategią.

Należy zdawać sobie jednak sprawę, że wykorzystywanie wzorców projektowych pomimo niezliczonej ilości korzyści generuje pewien narzut. Narzutem tym może być zwiększona liczba linii kodu, jaki należy wpisać, może być nim również zwiększony czas wykonywania się naszego programu.

Bibliografia

[ALUR2004] - D.Alur, J.Crupi, D.Malks, "Core J2EE Wzorce projektowe"
[Crawford] - W.Crawford, J.Kaplan, "J2EE Stosowanie wzorców projektowych"
[Sherif2000] - M.Y.Sherif, H.H.Ammar, "Pattern-Oriented Analysis and Design: Composing Patterns to Design Software Systems"

Bezpieczny to_param

2008-06-24T13:49:00.005+02:00

Wykorzystując Ruby on Rails chcielibyśmy tworzyć bardziej przyjazne/opisowe adresy url. Weźmy za przykład biuletyn rynku New Connect. W biuletynie tym znajdują się linki do bieżących lub archiwalnych artykułów. Byłoby lepiej, żeby zamiast wywołania www.ncbiuletyn.pl/czytaj/1, zobaczyć www.ncbiuletyn.pl/czytaj/1-debiuty_sierpniowe.html

Aby osiągnąć taki efekt nie musimy za wiele robić wystarczy nadpisać w klasie modelu metodę to_param. Możemy to zrobić w taki sposób:


 def to_param
    "#{self.id}-#{self.tytul}"
  end

Musimy jednak pamiętać, że nie każdy ciąg znaków będzie prawidłowym adresem url i niektóre artukuły mogą nam się po prostu przestać wyświetlać. Musimy zatem zabezpieczyć przed tym naszą aplikację i usuwać z pola niedozwolone znaki. Możemy to osiągnąć w poniższy sposób:


 def to_param
    "#{self.id}-#{self.tytul.gsub(/(\W)/,"_")}"
  end

Dodanie counter cache do istniejącej tabeli

2008-06-24T12:58:00.009+02:00

Dodanie counter cacha do isteniejącej tabeli (dla relacji jeden- wiele) rozpocząć powinniśmy od stworzenia migracji dodającej do tabeli (w obiekcie agregującym) dodatkowej kolumny. Załóżmy w tym przypadku, że w naszej aplikacji posiadamy tabele Miasta oraz tabelę powiaty. Obie są w relacji jeden-do-wielu.


class Miasto < ActiveRecord::Base
  validates_presence_of :nazwa, :message => "jest wymagana"
  belongs_to :powiat
end

class Powiat < ActiveRecord::Base
  validates_presence_of :nazwa, :message => "jest wymagana"
  has_many :miasta
end

Uwaga: jeżeli chcesz używać polskich nazw w modelach przeczytaj ten artykuł.

Zanim przejdziemy do modyfikacji tabel zaznaczmy w modelu, że chcemy używać kolumny counter_cache.


class Miasto < ActiveRecord::Base
  validates_presence_of :nazwa, :message => "jest wymagana"
  belongs_to :powiat, :counter_cache => true;
end

Następnie dodajmy migrację:


script/generate migration powiaty_add_counter_cache

W migracji wpisujemy następujący kod


 add_column :powiaty, :miasta_count, :integer, :default => 0
    Powiat.find(:all).each do |p|
      Powiat.update_counters p.id, :miasta_count => p.miasta.length
    end

W tym momencie nasza aplikacja będzie miała prawidłowo ustawione liczniki.

Counter Cache w ruby on rails dla relacji many-to-many

2008-06-24T11:33:00.020+02:00

Rails dostarcza wiele cennych narzędzi, które w nieprawdopodobny sposób potrafią przyspieszyć proces tworzenia aplikacji. Jednym z bardzo użytecznych mechanizmów jest wsparcie dla mechanizmu counter cache.

Aby zrozumieć jak działa ten mechanizm wyobraźmy sobie, że mamy relacje typu jeden do wielu. Dla przykładu w każdym powiecie znajduje się wiele miast.

Jeżeli chcielibyśmy w naszej aplikacji wyświetlać przy każdym powiecie informacje o liczbie miast jaka sie w nim znajduje musielibyśmy za każdym razem wywołać:


 Select count(*) from miasta where powiat_id = id

Łatwo się zorientować, że jeżeli liczba miast i powiatów jest duża to takie rozwiązanie jest wysoce nieefektywne. Rozwiązaniem staje się wprowadzenie dodatkowej kolumny do tabeli powiaty zawierającą policzoną wcześniej liczbę miast. Teraz pozostaje jedynie pilnowanieaby przy każdym dodaniu lub usunięciu relacji powiat - miasto informacja w dodatkowej kolumnie została zaktualizowana.

W przypadku przedstawionej tutaj relacji sam Rails czuwa nad tym aby liczba ta pozostała prawidłowa wystarczy, że zrobimy następujące kroki:

1.Zdefiniujemy migracje:


class CreateRelacja < ActiveRecord::Migration
  def self.up

    create_table :miasta do |t|
      t.string :nazwa, :limit => 35
      t.integer :miasto_id
      t.timestamps
    end

    create_table :powiaty do |t|
      t.string :nazwa, :limit => 35
      t.integer :miasta_count, :default => 0
      t.timestamps
    end

  end
end

Uwaga: bardzo ważne jest aby kolumna miasta_count zainicjowana została domyślną wartością 0 – w przeciwnym przypadu licznik nie będzie działał (jeżeli chcesz dodać counter_cache w istniejącej tabeli zobacz tego posta (http://mstanek.blogspot.com/2008/06/dodanie-counter-cache-do-istniejcej.html)).

2.W następnym kroku należy zmodyfikować klasy modelu:


class Miasto < ActiveRecord::Base
  validates_presence_of :nazwa, :message => "jest wymagana"
  belongs_to :powiat,:counter_cache => true;

end
class Powiat < ActiveRecord::Base
  validates_presence_of :nazwa, :message => "jest wymagana"
  has_many :miasta
end

Takie rozwiązanie jest szybkie i całkowicie wspierane przez Railsa. Niestety wsparcia takiego nie otrzymujemy dla relacji wiele do wiele.

W tym momencie za model posłuży nam baza usług medycznych informacja-madyczna.pl. Występuje tam związek pomiędzy specjalizacjami a lekarzami. Jest wielu lekarzy posiadających daną specjalizację, a każdy z nich może posiadać więcej niż jedną specjalizację. Jest to ewidentnie związek wiele do wiele.

Nasz model wygląda zatem w następujący sposób:


class Lekarz < ActiveRecord::Base
  has_and_belongs_to_many :specjalizacje
end

class Specjalizacja < ActiveRecord::Base
  has_and_belongs_to_many :lekarze
end

Aby załóżmy zatem, że chcemy mieć informacje dotyczącą ilości lekarzy z daną specjalizacją. W kodzie informację taką można uzyskać w nastepujący sposób:


 Specjalizacja.find_by_nazwa('ginekologia').lekarze.length

Niestety wyciągnięcie w ten sposób informacji dla każdej specjalizacji jest bardzo czasochłonne. Dodajmy zatem kolumnę licznika w tabeli specjalizacje, tak abyśmy mogli wyliczoną w powyższy sposób liczbę zachować. Tworzymy zatem migrację a w migracji dodajemy następujący kod:


    add_column :specjalizacje, :lekarze_count, :integer, :default => 0
    Specjalizacja.find(:all).each do |s|
      s.lekarze_count = s.lekarze.length
      s.save
    end

Proszę zauważyć, że aby zachować jednolity zapis z wbudowanym mechanizmem couter_cache kolumna została nazwana w analogiczny sposób.

W tym momencie posiadamy już informację o liczności każdego związku – jest ona przechowywana w klasie Specjalizacja. Teraz pozostaje najtrudniejsza część, należy mianowicie zadbać o to, żeby w czasie dodawania bądź usuwania obiektów z relacji licznik ulegał zmianie. Należy tutaj zwrócić uwagę, że modyfikaje tego typu możemy wprowadzać po obu stronach relacji. Pokaże to na przykładzie dodania nowej specjalizacji lekarzowi, którą możemy wykonać na dwa sposoby:


   lekarz = Lekarz.find_by_imie_and_nazwisko('Jan','Kowalski')
   specjalizacja = Specjalizacja.find_by_nazwa('ginekologia')

1. sposób:


   lekarz.specjalizacje << specjalizacja 
   lekarz.save

2. sposób:


   specjalizacja.lekarze << lekarz
   specjalizacja.save

Z dokumentacji relacji has_many dowiadujemy się, że posiada ona dwa bardzo pomocne nam modyfikatory :before_add oraz :before_remove. Pozwolą nam one na śledzenie zmian, które powinny zostać odzwierciedlone w wartości licznika. Rozszerzmy zatem naszą klasę Lekarz o śledzenie zmian i poprawę licznika:


class Lekarz < ActiveRecord::Base
has_and_belongs_to_many :specjalizacje, 
             :before_add => :counter_inc, 
             :before_remove => :counter_dec

  def counter_inc(t)
    counter_change(t, 1)
  end
  
  def counter_dec(t)
    counter_change(t, -1)
  end

  private
  def counter_change(object, amount)
    object.lekarze_count = object.lekarze_count+amount;
    object.save
  end
end

A następnie klasę Specjalizacja


class Specjalizacja < ActiveRecord::Base
 has_and_belongs_to_many :lekarze, 
             :before_add => :counter_inc, 
             :before_remove => :counter_dec

  def counter_inc(t)
    t.counter_inc(self)
  end
  
  def counter_dec(t)
    t.counter_dec(self)
  end
end

W tym momencie udało nam się stworzyć mechanizm counter_cache dla relacji wiele do wiele (many-to-many). Oczywiście pozostaje nam napisanie odpowiednich testów, ale to zadanie pozostawiam już czytelnikowi.

Poprawione wyrażenie regularne dla e-maila

2008-06-16T16:09:00.009+02:00

Ponieważ wyrażenie regularne służące do weryfikacji poprawności e-maila podane w dokumentacji rubiego nie jest doskonałe (zakłada konieczność wprowadzenia e-maila) oraz umożliwia wstawienie w nim znaku '?' poniżej podaje zmodyfikowane wyrażenie nie posiadający w.w. wad:


 validates_format_of :email, 
    :with => /(^([^@\s?]+)@((?:[-_a-z0-9]+\.)+[a-z]{2,})$)|(^$)/i,
    :message => "ma błędny format (przykładowy poprawny email przyklad@domena.pl)"

Korzystając z okazji podam również wyrażenie regularne które może służyć do weryfikacji poprawności wpisanego numeru telefonu:


 validates_format_of :telefon, 
    :with => /^[+]{0,1}[-0-9()\s]+$/,
    :message => "ma błędny format (przykłady poprawnych: +48 071 123 123, 012-12-332)"

Why ActiveRecord::HasManyThroughAssociationNotFoundError: Could not find the association arrise?

2008-06-16T15:53:00.014+02:00

Tworząc zależności wiele do wiele możemy wykorzystać przełącznik through i zapisać w danej asocjacji dodatkowe informacje np. relacja Czytelnik - Artykul, może zawierać np. ocenę wystawioną danemu artykułowi. Nie wchodząc w szczegóły jak tworzyć takie związki (na sieci znajduje się kilka dość dobrych tutoriali które łątwo wygooglować), czasami napotkać na poniższy wyjątek:

ActiveRecord::HasManyThroughAssociationNotFoundError: Could not find the association

Aby rozwiązać ten problem należy pamiętać, że klasa będąca złączeniem musi być jawnie dodana do zależności w klasach bazowych. Na przykładzie:


class Lekarz < ActiveRecord::Base
   has_many :placowki, :through => :pracownicy
   has_many :pracownicy
end

class Placowka < ActiveRecord::Base
  has_many :lekarze, :through => :pracownicy
  has_many :pracownicy
end

class Pracownik < ActiveRecord::Base
  belongs_to :lekarz
  belongs_to :placowka
end

LightWindow 2 i problem z flashowymi bannerami

2008-06-09T01:44:00.008+02:00

Korzystając z doskonałego skryptu tworzącego tak zwany LightWindow (http://mysticearth.wordpress.com/2007/07/12/lightwindow-2-available/), napotkałem na dość uciążliwy problem. Sprawa polega na tym, że okno podglądu tworzone jest dynamicznie po kliknięciu na link. Zanim wyświetlony zostanie podgląd zlinkowanego zasobu biblioteka generuję animację rozwijającą w dość atrakcyjny sposób okienko. Wszystko jest dobrze, aż do momentu kiedy animacja ta nie jest wyświetlana na stronie, która zawiera flashowe dodatki. Efekt jest taki, że wszystkie flasha znajdują się nad animowaną warstwą okienka podglądu. Ostateczny wygląd jest dosyć nieciekawy.

Rozwiązań problemu jest zapewne wiele, ale ostatecznie zdecydowałem się na metodę, polegającą na tym, że wszystkie elementy flashowe przed wywołaniem okienka light window są ukrywane, a po jego wyłączeniu na nowo pokazywane.

Aby osiągnąć taki efekt należy skorzystać z dobrodziejstw jakie daje nam biblioteka Prototype (standardowo dołączana do projektu).


  <script type="text/javascript">
     swfobject.embedSWF("<%= url %>", "banner_<%=  banner.id %>", "700", "100", "9.0.0");
  </script>

  <a href="http://<%= banner.url %>" style="position:relative;z-index:1;" class="banner">
     <div id="banner_<%=  banner.id %>" style="z-index:1;" >
      <p><img src="<%= @url_for_app +banner.plik.public_filename if banner.plik %>"/></p>
     </div>
  </a>

Uwaga: do osadzenia obiektu Flash została użyta biblioteka SWFObject (gorąco polecam).

Następnie modyfikujemy dwie funkcji w lightwindow.js. Szukamy następującej linijki:


   activate : function(e, link){

Dla ułatwienia powiem że jest to linia 252 i na samym początku dodajemy następujący wiersz:


($$('.banner').invoke('hide'));

Następnie w funkcji dekatywacji (linia 277):


 deactivate : function(){

wstawiamy


       ($$('.banner').invoke('show'));

Dzięki takim kosmetycznym zmianom nasz problem został rozwiązany.

Przekazanie bloku kodu do metody helpera

2008-06-09T01:18:00.023+02:00

Korzystanie z dobrodziejstwa rubiego jakim jest przekazywanie bloku kodu do metody można wykorzystywać projektując metody w klasach Helperów. Aby wykorzystać ten mechanizm należy jednak zastosować specjalną kontrukcję, którą pokrótce postaram się wyjaśnić.

Załóżmy, że projektowana przez nas witryna składa się z wielu modułów, z których każdy posiada nagłówek oraz treść. Za każdym razem te dwie rzeczy opakowywane są w serię divów z przypisanymi odpowidnimi klasami. Nasze zadanie polegać będzie na tym aby napisać metodę w klasie ApplicationHelper umożliwiającą wstawienie wspomnianego modułu w dowolnym widoku.

Zacznijmy więc od definicji metody:


def modul_tematyczny(tytul, &block) 
end

Następnie w widoku umieśćmy następujące wywołanie:


  <div ....> .... </div>
  <% modul_tematyczny("Wstawiony modul") do %>
    <ul>
     <% @wiadomosci.each do |wiadomosc|%>
        <li> <%= wiadomosc.temat-%> - <%= wiadomosc.updated_at %></li>
     <% end %>
    </ul>
  <% end%>
  <div ....> .... </div>

Powróćmy w do helpera i dodajmy odpowiedni kod, tak aby wszystko razem zaczęło działać:


def modul_tematyczny(tytul, &block) 
 blok = capture(&block)

res = <<HTML
  <div class="modul">
    <h1 class="tytul">#{tytul}</h1>
    <div class='zawartosc'>
      #{blok}
    </div>
   </div>
HTML

 concat(res, block.binding)
end

Jak nie trudno zauważyć całą magię stanowią dwa wywołania, które wiążą blok kodu ze zmienną, a następnie zwracają wynik. Zastosowany przykład jest wysoce niedoskonały, ale daje pogląd na możliwości jakie daje nam definiowanie helperów wykorzystujących bloki kodu.

Problem z podwójnym kliknięciem w LightWindow 2

2008-06-02T23:47:00.005+02:00

Mam przyjemność być użytkownikiem jednej z lepszych bibliotek JavaScript do generowania tak zwanych Light Box/Window http://www.stickmanlabs.com/lightwindow/. Niestety zauważyłem, że posiada ona dość nieprzyjemny mankament objawiający się podczas podwójnego kliknięcia na linku z przypisanym stylem lightwindow. Domyślnie biblioteka rozbudowuje dla takiego elementu drzewo DOM dodając mu właściwość onClick. Niestety jeżeli nastąpi podwójne kliknięcie ramka zwiększa swoją szerokość dwa razy, co w niektórych przypadkach powoduje że staje sie szersza niż okno przeglądarki. Bezpośrednia ingerencja w bibliotekę nie jest trywialna jednak prosty trick zastosowany (niestety na każdym łączu ze stylem lightwindow) pozwala rozwiązać problem. Wystarczy dopisać:

ondblclick="return false;"

Rails a upload plików z klasą polimorficzną (Attachment_fu)

2008-03-28T13:34:00.012+01:00

Polecam zainstalowanie plug-inu Attachment_fu


script/plugin install http://svn.techno-weenie.net/projects/plugins/attachment_fu

Następnie tworzymy model np. File /lub plik - tworząc odpowiednie inflections/, czyli


scrip/generate model Plik

w stworzona migracja powinna wyglądać następująco:


class CreatePliki < ActiveRecord::Migration
  def self.up
      create_table :pliki do |t|
      t.column :filename, :string
      t.column :size, :integer
      t.column :content_type, :string
      t.column :thumbnail, :string
      t.column :parent_id, :integer
      t.column :height, :integer
      t.column :width, :integer
      
      # Obsługa polimorfizmu
      t.column :zasob_id, :integer
      t.column :zasob_type, :string
      
      t.timestamps
    end
  end

  def self.down
    drop_table :pliki
  end
end

A nasz plik modelu powinien zawierać następujący wpis:


class Plik < ActiveRecord::Base
  belongs_to :zasob, :polymorphic => true # Polimorfizm
  
  has_attachment :content_type => :image, 
                   :storage => :file_system, 
                   :max_size => 2.megabytes,
                   :resize_to => '300x300>',
                   :size => 0..2.megabyte,
                   :thumbnails => {
                      :small => '50x50>',
                      :medium => '100x100>',
                      :big => '200x200>'
                   },
                   :processor => :MiniMagick;

  validates_as_attachment
end

Zdefiniowane zostały tutaj opcje zapisu zdjęcia uwzględniające tworzenie miniaturek za pomocą biblioteki MiniMagic. Aby ją zainstalować powinniśmy wpisać w konsoli:

sudo gem install mini_magick

Teraz wiążemy nasze zdjęcie z jakąś istniejącą klasą modelu. W naszym przypadku niech będzie nią klasa produkt:


class Produkt < ActiveRecord::Base

  has_and_belongs_to_many :kategorie
  belongs_to :producent

  has_one :plik, :as => :zasob #,:class_name => 'Plik'

  validates_presence_of :nazwa, :message => "nie może być pusta"
  validates_presence_of :cena, :message => "nie może być pusta"
  
  validates_length_of :nazwa, :minimum=>2, :message=> "musi składać się przynajmniej z dwóch znaków"
  validates_numericality_of :cena, :greater_than_or_equal_to => 0, :message => "nie może być ujemna"

end

W następnej kolejności musimy uzupełnić widoki o możliwość dodawania oraz wyświetlania naszego obrazka. W formularzu dla akcji new oraz edit powinniśmy mieć następujący wpis


<% form_for(@produkt, :html => { :multipart => true }) do |f| %>
  ....
  <%= file_field :plik, :uploaded_data %>
  ....
<% end %>

Musimy również uzupełnić nasz kotroler o zapis załączonego pliku. W akcji update oraz create należy dodać następujący kod:


   unless params[:plik].blank?
      @produkt.plik = Plik.new(params[:plik])
      p.save 
   end

Wyświetlić nasz załączony plik możemy w następujący sposób:


<%= image_tag(@produkt.plik.public_filename(:big)) if @produkt.plik%>

gdzie :big to nazwa thumbnailsa podana w modelu. Jeżeli nie podamy tego parametru wyświetlony będzie oryginalny obrazek.

Przedstawiłem podstawowe kroki niezbędne do dodania możliwości przechowywania plików związanych z naszymi klasami modelu. Po więcej informacji odsyłam do:

http://www.railslodge.com/plugins/108-attachment-fu
http://clarkware.com/cgi/blosxom/2007/02/24
http://blog.defv.be/2007/12/19/attachment_fu-with-polymorphic-association
http://khamsouk.souvanlasy.com/2007/5/1/ajax-file-uploads-in-rails-using-attachment_fu-and-responds_to_parent

Ruby MySQL i UTF8

2008-03-28T12:33:00.005+01:00

Najprostszy sposób na ustawienie MySQL do pracy w UTF-8, to modyfikacja pliku my.cnf. Plik ten znajduje się w katalogu /etc/mysql/my.cnf. W pliku tym w sekcji zmodyfikować 2 sekcje [mysqld] oraz [client]:

[mysqld]
character-set-server = UTF8
default-character-set = UTF8
collation_server = utf8_polish_ci

[client]
default-character-set=utf8

Następnie aby ruby poprawnie radził sobie z zapisem do tak stworzonej bazy należy zmodyfikować plik environment.rb znajdujący się w podkatalogu /config/. Do pliku tego dodajemy następujący wpis:

config.action_controller.default_charset = "utf-8"

Jeżeli tworzyliśmy projekt za pomocą rails -d mysql nazwa_projektu automatycznie w pliku konfigurującym połączenie z baza danych powinniśmy otrzymać podobny zestaw wpisów:

development:
adapter: mysql
encoding: utf8
database: projekt_development
username: root
password:
socket: /var/run/mysqld/mysqld.sock

/Podobmne wpisy będą wygenerowane również dla środowiska test oraz production/

Uwaga: jeżeli pomimo wprowadzenia zmian opisanych powyżej nasza baza danych dalej błędnie obsługuje polskie znaki dialektyczne, najprostszym sposobem aby sobie z tym poradzić jest usunąć wszystkie tabele i stworzyć je na nowo /rake db:create:all oraz rake migrate/.

Ruby on Rails - polskie komunikaty błędów przy walidacji

2008-03-20T20:41:00.009+01:00

W przypadku używania walidatorów dla stron polskojęzycznych pojawia się problem z niezręcznymi angielskimi komunikatami błędów. Aby spolonizować w prosty sposób nasze komunikaty wystarczy dokonać tylko kilku modyfikacji.

Załóżmy, że w naszym modelu mamy następującą klasę:

class Produkt < ActiveRecord::Base
#pola => Nazwa, Cena,
end

Spolonizowana walidacja mogłaby wyglądać w takim przypadku następująco:

class Produkt validates_presence_of :nazwa, :message => "nie może być pusta"
validates_presence_of :cena, :message => "nie może być pusta"

validates_length_of :nazwa, :minimum=>2, :message=> "musi składać się przynajmniej z dwóch znaków"
validates_numericality_of :cena, :greater_than_or_equal_to => 0, :message => "nie może być ujemna"

end

W tym momencie część pracy już za nami. Metoda

<%= error_message_for :produkt -%>

działa już prawie tak jak byśmy chcieli. Pozostaje usunięcie nagłówka i wstępnego komunikatu, który w dalszym ciągu pojawia się w języku angielskim. Rozwiązanie jest dość trywialne (oczywiście jeżeli wiadomo gdzie szukać). Poprawiona wersja metody wygląda więc tak:

<%= error_messages_for :produkt, :header_message => "Błąd !", :message => "Lista błędów:"%>

Polecam również lekturę:
http://www.rubyonrails.pl/forum/p3572-2007-10-22-00:50:44

Rails paginacja z polskimi nazwami w osobnej metodzie helpera

2008-03-19T20:57:00.004+01:00

Aby nie powielać wpisywanego kodu paginatora (will_paginate) parametryzując go o polskie napisy dla przycisków 'next' i 'previous' możemy stworzyć oddzielną metodę w module ApplicationHelper.


def paginacja(kolekcja)
       will_paginate kolekcja, 
            :inner_window => 10, 
            :outer_window => 10, 
            :prev_label => "« Poprzednie", 
            :next_label => "Następne »"
end

Następnie w widoku możemy wywołać tą metodę w następujący sposób.

<%= paginacja @produkty %>

Oczywiście aby działała cała paginacja należy zainstalować plugin will_paginate oraz przygotować odpowiednio kolekcję w kontrolerze:


@produkty = Produkt.paginate(:order => 'nazwa DESC',
                               #:conditions => ["active = ?", 1]
                               :per_page => 10,
                               :page => params[:page])

Jeżeli przeczytałeś ten artykuł do końca to prawdopodobnie zainteresuje Ciebie również paginacja w Rails 2.1

Umieszczenie grafiki w link_to

2008-03-19T13:55:00.003+01:00

Aby umieścieć obrazek w hiperłączu wystarczy w widoku *.html.erb dodać następującą linijkę:

<%= link_to image_tag("obrazek.gif", :border=>0), :action => 'akcja', :id => obiekt %>

Ruby on Rails 2.0.2 i inflections (polski pluralize)

2008-03-18T22:42:00.005+01:00

Ruby posiada fantastyczną cechę jaką jest możliwość odmiany rzeczowników i na ich podstawie automatycznego tworzenia nazw tabel oraz kontrolerów. Niestety własność ta działa standardowo tylko dla języka angielskiego. Jeżeli chcemy jednak aby w naszym projekcie była możliwość posługiwania się nazwami polskimi możemy dodać nowe reguły do railsa, które umożliwią mu odmianę polskich wyrazów.

Sprawa odmiany wydaje się w railsie 2.0.2 dość trywialna. Wystarczy dodać do pliku config/initializers/inflections.rb kilka linijek. Pamiętajmy jednak, że rails do prawidłowego działania potrzebuje poprawnie zdefiniowane reguły dla języka angielskiego dlatego nie usuwajmy tych reguł metodą clear :all.

Nowe polskie rzeczowniki możemy dodawać jako rzeczowniki nieregularne i w takim przypadku rails nie protestuje i wszystkie inne funkcjonalności powinny działać poprawnie wpisujemy więc:

Inflector.inflections do |inflect|
inflect.irregular 'konto', 'konta'
end

I wywolujac "script/generate model Konto uzytkownik:string haslo:string", a następnie "rake db:migrate" w naszej bazie danych powstanie tabela konta.

Problem pojawi się jeżeli będziemy chcieli użyć naszych rzeczowników w metodzie scaffold. Domyślnie nie są generowane odpowiednie ścieżki routingu dlatego musimy to naprawić wpisując:

rake routes

Od teraz możemy cieszyć się polskimi nazwami w railsie.

2006-03-07T11:01:00.001+01:00

test