ANNdotNET v1.0 has been released


Half year ago, in this post announced the new open source project ANNdotNET, which was ANN part of the GPdotNET v4 – artificial intelligence tool. On that day I finished my new book about machine learning and genetic programming when also released the new version of GPdotNET V5.0 genetic programming tool, without ANN and other non GP related modules. Now my second big open source project achieved the first stable released.

ANNdotNET (http://github.com/bhrnjica/anndotnet) is deep learning tool on .NET platform, which has similar workflow as GPdotNET. Both projects share several modules, mostly for data preparation, and model evaluation since all that stuff are same.

anndotnet_gpdotnet.png

ANNdotNET is project which is more than GUI tool, since it contains CMD tool, which can be part of bigger cloud solution. There are several key concepts of the project which is worth to mention here:

1. Machine Learning Configuration mlconfig file

The ANNdotNET is based on so called machine learning configuration file, where everything about data, training and learning parameters, as well as neural network layers are store in the file so called mlconfig file. Along mlconfig file, there are several other file types generated during development of the ml solution. The mlconfig file can be shared between cloud services in order to prepare and transform data, train, evaluate or export ml models. If you want to see more information about files in ANNdotNET you can look at the wiki page of the project. Since the mlconfig file is independent of the tool, it can be executed with GUI or CMD tool, or any other custom tool, implemented on anndotnet API.

2. Machine Learning Project Explorer

In order to start developing ml solution with ANNdotNET, the first thing you do is create annproject file, by selecting New option from the Application command. Under annproject the user can create as many mlconfig files as he/she want. The annproject and related mlconfig files are presented in the ML Project Explorer, where the user can manage them as ordinary list items.

mlproject_explorer.png

3. ANNdotNET MLEngine – Machine Learning Engine

ANNdotNET introduces the ANNdotNET Machine Learning Engine (MLEngine) which is responsible for training and evaluation models defined in the mlconfig files.The ML Engine relies on Microsoft Cognitive Toolkit, CNTK open source library which is proved to be one of the best open source library for deep learning. Through all application’s components ML Engine exposed all great features of the CNTK e.g. GPU support for training and evaluation, different kind of learners, but also extends CNTK features with more Evaluation functions (RMSE, MSE, Classification Accuracy, Coefficient of Determination, etc.), Extended Mini-batch Sources, Trainer and Evaluation models.

anndotnet_mlengine

MLEngine is build on top of CNTK and .NET, with ability to provide backed component for any cloud/on-premise  ML solution.

4. Visual Neural Network Designer

ML Engine also contains the implementation of neural network layers which supposed to be high level CNTK API very similar as layer implementation in Keras and other python based deep learning APIs. With this implementation the ANNdotNET implements the Visual Neural Network Designer called ANNdotNET NNDesigner which allows the user to design neural network configuration of any size with any type of the layers. In the first release the following layers are implemented:

  • Normalization Layer – takes the numerical features and normalizes its values before getting to the network. More information can be found here.
  • Dense – classic neural network layer with activation function,
  • LSTM – LSTM layer with option for peephole and self-stabilization.
  • Embedding – Embedding layer.
  • Drop – drop layer.

More layer types will be added in the future release. More information about Visual Network Designer can be found on previous blog post.

5. Data Transformation

Along the ml related stuff, ANNdotNET implement set of components for data transformation from raw dataset into mlready datasets. The user doesn’t worry about complex CNTK file format, one-hot encoding, and other data and variable transformation e.g handling missing values, data normalization etc. Data transformation starts loading raw data file into ANNdotNET, then with set of GUI related options the data can be completely prepared to mlready dataset. There are set of short videos about how to quickly transform raw dataset into mlready dataset.

5. Model Evaluation, Saving Good Models & Retraining Trained Models

Once the model is trained, ANNdotNET provides basic evaluation tool for evaluating trained models. The MLEvaluator contains set of basic options in order to evaluate regression, binary or multi-class classification models. Without leaving ANNdotNET the user has ability to decide if the model is good or not by performing set of statistics measures agains model and related datasets (training, validation and test). Beside evaluation, ANNdotNET offers instantly evaluation during training phase, by providing an option for saving good models during training phase. On this way ANNdotNET has ability to select best trained model regardless of the number of iterations. Different strategy for selecting the best model among set of saved models will be implemented in the future. Also any previous trained models can be trained again from the last check point. This is important option in various scenario. For example to change some parameters and continue training. Also this option has ability to start training model on one machine or environment, and then continue with training on different machine or environment.

Summary

ANNdotNET – is an open source project for deep learning on .NET Platform. This is complete GUI solution for data preparation, training, evaluation and deployment ml models. ANNdotNET introduces the ANNdotNET Machine Learning Engine ( MLEngine) which is responsible for training and evaluation models defined in the mlconfig files. The MLEngine relies on Microsoft Cognitive Toolkit, CNTK open source library which is proved to be one of the best open source library for deep learning. Through all application’s components MLEngine exposed all great features of the CNTK e.g. GPU support for training and evaluation, different kind of learners. MLEngine also extends CNTK features with more evaluation functions (RMSE, MSE, Classification Accuracy, Coefficient of Determination, etc.), Extended Mini-batch Sources, Trainer and Evaluation models.
The process of creating, training, evaluating and exporting models is provided from the GUI Application and does not require knowledge for supported programming languages.

The ANNdotNET is ideal in several scenarios:

  • more focus on network development and training process using classic desktop approach, instead of focusing on coding,
  • less time spending on debugging source code, more focusing on different configuration and parameter variants,
  • ideal for engineers/users who are not familiar with programming languages,
  • in case the problem requires coding custom models, or training process, ANNdotNET CMD provides high level of API for such implementation,
  • all ml configurations developed with GUI tool,can be handled with CMD tool and vice versa.


In case you like this project star it on GitHub at http://github.com/bhrnjica/anndotnet. In case you want to use it in you academic paper, please cite it appropriate as specified at this link: https://doi.org/10.5281/zenodo.1461722

 

Descriptive statistics and data normalization with CNTK and C#


As you probably know CNTK is Microsoft Cognitive Toolkit for deep learning. It is open source library which is used by various Microsoft products. Also the CNTK is powerful library for developing custom ML solutions from various fields with different platforms and languages. What is also so powerful in the CNTK is the way of the implementation. In fact the library is implemented as series of computation graphs, which  is fully elaborated into the sequence of steps performed in a deep neural network training.

Each CNTK compute graph is created with set of nodes where each node represents numerical (mathematical) operation. The edges between nodes in the graph represent data flow between operations. Such a representation allows CNTK to schedule computation on the underlying hardware GPU or CPU. The CNTK can dynamically analyze the graphs in order to to optimize both latency and efficient use of resources. The most powerful part of this is the fact thet the CNTK can calculate derivation of any constructed set of operations, which can be used for efficient learning  process of the network parameters. The flowing image shows the core architecture of the CNTK.

On the other hand, any operation can be executed on CPU or GPU with minimal code changes. In fact we can implement method which can automatically takes GPU computation if available. The CNTK is the first .NET library which provide .NET developers to develop GPU aware .NET applications.

What this exactly mean is that with this powerful library you can develop complex math computation directly to GPU in .NET using C#, which currently is not possible when using standard .NET library.

For this blog post I will show how to calculate some of basic statistics operations on data set.

Say we have data set with 4 columns (features) and 20 rows (samples). The C# implementation of this 2D array is show on the following code snippet:

static float[][] mData = new float[][] {
new float[] { 5.1f, 3.5f, 1.4f, 0.2f},
new float[] { 4.9f, 3.0f, 1.4f, 0.2f},
new float[] { 4.7f, 3.2f, 1.3f, 0.2f},
new float[] { 4.6f, 3.1f, 1.5f, 0.2f},
new float[] { 6.9f, 3.1f, 4.9f, 1.5f},
new float[] { 5.5f, 2.3f, 4.0f, 1.3f},
new float[] { 6.5f, 2.8f, 4.6f, 1.5f},
new float[] { 5.0f, 3.4f, 1.5f, 0.2f},
new float[] { 4.4f, 2.9f, 1.4f, 0.2f},
new float[] { 4.9f, 3.1f, 1.5f, 0.1f},
new float[] { 5.4f, 3.7f, 1.5f, 0.2f},
new float[] { 4.8f, 3.4f, 1.6f, 0.2f},
new float[] { 4.8f, 3.0f, 1.4f, 0.1f},
new float[] { 4.3f, 3.0f, 1.1f, 0.1f},
new float[] { 6.5f, 3.0f, 5.8f, 2.2f},
new float[] { 7.6f, 3.0f, 6.6f, 2.1f},
new float[] { 4.9f, 2.5f, 4.5f, 1.7f},
new float[] { 7.3f, 2.9f, 6.3f, 1.8f},
new float[] { 5.7f, 3.8f, 1.7f, 0.3f},
new float[] { 5.1f, 3.8f, 1.5f, 0.3f},};

If you want to play with CNTK and math calculation you need some knowledge from Calculus, as well as vectors, matrix and tensors. Also in CNTK any operation is performed as matrix operation, which may simplify the calculation process for you. In standard way, you have to deal with multidimensional arrays during calculations. As my knowledge currently there is no .NET library which can perform math operation on GPU, which constrains the .NET platform for implementation of high performance applications.

If we want to compute average value, and standard deviation for each column, we can do that with CNTK very easy way. Once we compute those values we can used them for normalizing the data set by computing standard score (Gauss Standardization).

The Gauss standardization is calculated by the flowing term:

nValue= \frac{X-\nu}{\sigma},
where X- is column values, \nu – column mean, and \sigma– standard deviation of the column.

For this example we are going to perform three statistic operations,and the CNTK automatically provides us with ability to compute those values on GPU. This is very important in case you have data set with millions of rows, and computation can be performed in few milliseconds.

Any computation process in CNTK can be achieved in several steps:

1. Read data from external source or in-memory data,
2. Define Value and Variable objects.
3. Define Function for the calculation
4. Perform Evaluation of the function by passing the Variable and Value objects
5. Retrieve the result of the calculation and show the result.

All above steps are implemented in the following implementation:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CNTK;
namespace DataNormalizationWithCNTK
{
    class Program
    {
       static float[][] mData = new float[][] {
        new float[] { 5.1f, 3.5f, 1.4f, 0.2f},
        new float[] { 4.9f, 3.0f, 1.4f, 0.2f},
        new float[] { 4.7f, 3.2f, 1.3f, 0.2f},
        new float[] { 4.6f, 3.1f, 1.5f, 0.2f},
        new float[] { 6.9f, 3.1f, 4.9f, 1.5f},
        new float[] { 5.5f, 2.3f, 4.0f, 1.3f},
        new float[] { 6.5f, 2.8f, 4.6f, 1.5f},
        new float[] { 5.0f, 3.4f, 1.5f, 0.2f},
        new float[] { 4.4f, 2.9f, 1.4f, 0.2f},
        new float[] { 4.9f, 3.1f, 1.5f, 0.1f},
        new float[] { 5.4f, 3.7f, 1.5f, 0.2f},
        new float[] { 4.8f, 3.4f, 1.6f, 0.2f},
        new float[] { 4.8f, 3.0f, 1.4f, 0.1f},
        new float[] { 4.3f, 3.0f, 1.1f, 0.1f},
        new float[] { 6.5f, 3.0f, 5.8f, 2.2f},
        new float[] { 7.6f, 3.0f, 6.6f, 2.1f},
        new float[] { 4.9f, 2.5f, 4.5f, 1.7f},
        new float[] { 7.3f, 2.9f, 6.3f, 1.8f},
        new float[] { 5.7f, 3.8f, 1.7f, 0.3f},
        new float[] { 5.1f, 3.8f, 1.5f, 0.3f},};
        static void Main(string[] args)
        {
            //define device where the calculation will executes
            var device = DeviceDescriptor.UseDefaultDevice();

            //print data to console
            Console.WriteLine($"X1,\tX2,\tX3,\tX4");
            Console.WriteLine($"-----,\t-----,\t-----,\t-----");
            foreach (var row in mData)
            {
                Console.WriteLine($"{row[0]},\t{row[1]},\t{row[2]},\t{row[3]}");
            }
            Console.WriteLine($"-----,\t-----,\t-----,\t-----");


            //convert data into enumerable list
            var data = mData.ToEnumerable<IEnumerable<float>>();

            
            //assign the values 
            var vData = Value.CreateBatchOfSequences<float>(new int[] {4},data, device);
            //create variable to describe the data
            var features = Variable.InputVariable(vData.Shape, DataType.Float);

            //define mean function for the variable
            var mean =  CNTKLib.ReduceMean(features, new Axis(2));//Axis(2)- means calculate mean along the third axes which represent 4 features
            
            //map variables and data
            var inputDataMap = new Dictionary<Variable, Value>() { { features, vData } };
            var meanDataMap = new Dictionary<Variable, Value>() { { mean, null } };

            //mean calculation
            mean.Evaluate(inputDataMap,meanDataMap,device);
            //get result
            var meanValues = meanDataMap[mean].GetDenseData<float>(mean);

            Console.WriteLine($"");
            Console.WriteLine($"Average values for each features x1={meanValues[0][0]},x2={meanValues[0][1]},x3={meanValues[0][2]},x4={meanValues[0][3]}");

            //Calculation of standard deviation
            var std = calculateStd(features);
            var stdDataMap = new Dictionary<Variable, Value>() { { std, null } };
            //mean calculation
            std.Evaluate(inputDataMap, stdDataMap, device);
            //get result
            var stdValues = stdDataMap[std].GetDenseData<float>(std);
            
            Console.WriteLine($"");
            Console.WriteLine($"STD of features x1={stdValues[0][0]},x2={stdValues[0][1]},x3={stdValues[0][2]},x4={stdValues[0][3]}");

            //Once we have mean and std we can calculate Standardized values for the data
            var gaussNormalization = CNTKLib.ElementDivide(CNTKLib.Minus(features, mean), std);
            var gaussDataMap = new Dictionary<Variable, Value>() { { gaussNormalization, null } };
            //mean calculation
            gaussNormalization.Evaluate(inputDataMap, gaussDataMap, device);

            //get result
            var normValues = gaussDataMap[gaussNormalization].GetDenseData<float>(gaussNormalization);
            //print data to console
            Console.WriteLine($"-------------------------------------------");
            Console.WriteLine($"Normalized values for the above data set");
            Console.WriteLine($"");
            Console.WriteLine($"X1,\tX2,\tX3,\tX4");
            Console.WriteLine($"-----,\t-----,\t-----,\t-----");
            var row2 = normValues[0];
            for (int j = 0; j < 80; j += 4)
            {
                Console.WriteLine($"{row2[j]},\t{row2[j + 1]},\t{row2[j + 2]},\t{row2[j + 3]}");
            }
            Console.WriteLine($"-----,\t-----,\t-----,\t-----");
        }

        private static Function calculateStd(Variable features)
        {
            var mean = CNTKLib.ReduceMean(features,new Axis(2));
            var remainder = CNTKLib.Minus(features, mean);
            var squared = CNTKLib.Square(remainder);
            //the last dimension indicate the number of samples
            var n = new Constant(new NDShape(0), DataType.Float, features.Shape.Dimensions.Last()-1);
            var elm = CNTKLib.ElementDivide(squared, n);
            var sum = CNTKLib.ReduceSum(elm, new Axis(2));
            var stdVal = CNTKLib.Sqrt(sum);
            return stdVal;
        }
    }

    public static class ArrayExtensions
    {
        public static IEnumerable<T> ToEnumerable<T>(this Array target)
        {
            foreach (var item in target)
                yield return (T)item;
        }
    }
}

The output for the source code above should look like:

Poglavlje III – IZVODI FUNKCIJE


Zadnji u nizu blog postova teksta iz 1996 godine. Cjelokupan tekst može se pogledati ovdje.

1.1 Povijest izvoda

Kad ne bi bilo izvoda (derivacije) svi naši snovi vezani za uspjeh u polju matematike bili bi lako ostvarivi. Matematika bi se bavila samo elementarnim stvarima. Doista, matematika bi se svela na elementarnu matematiku. Kažu da padom jabuke na Newtonovu glavu sve je krenulo drugačije. Ta nesretna jabuka okrenula je Newtona tada ka spoznaji osnovnih zakona dinamike i gravitacije. Newton je za dokaz svojih zakona, povrh siromašnih eksperimenata koje je izvodio, za svoje zakone morao naći matematički aparat da ih dokaže. Otkrićem diferencijalnog i integralnog računa Newton je dokazao svoje zakone, a nama običnim smrtnicima – studentima ostavio jabuke i diferencijalni račun za posvetu.

Mnogi filozofi se spore o tome koliko je jabuka palo na Newtonovu glavu. Veliki dio njih zagovara tezu da je nemoguće da padom samo jedne jabuke opravdava činjenicu Newtonovog djela. Po njihovom mišljenju smatra se da je na Newtonovu glavu palo bar desetak jabuka i to krupnijih koje rastu na vrhu drveta, u malom vremenskom intervalu clip_image002. Kad ne bi bilo izvoda, čitav ovozemaljski razvoj tehnike i tehnologije sigurno bi bio na stepenu razvoja u Newtonovo doba. Možemo s pravom reći da smo imali sreće. Da nema izvoda sigurno ne bi bilo ni kompjutera, ni video igrica ni flipera. Povrh svih mučnina koje nam zadaje izvod, ipak neka samo postoje kompjuteri i ostalo uz njih, a za izvode ćemo lako – rekao je neko iz mase.

POJMOVI PREKO KOJIH SE DEFINIŠE IZVOD

Da bismo definisali izvod neke funkcije moramo objasniti neke sporedne stvari koje okružuju izvod, a to su:

• Tangenta i konstrukcija tangente

• Srednja i trenutna brzina

1.1.1 Konstrukcija tangente

Definicija tangente u elementarnoj geometriji, koja se radi u osnovnoj školi, definiše tangentu kao jednu pravu koja ima samo jednu zajedničku tačku sa kružnicom. Međutim, ima tu nešto. Tačno je da se radi o jednoj tački i tačno je da se radi o pravoj. Međutim, kada pogledamo iz drugog ugla stvari odnosno sliku 3.1, vidimo kako jedna prava clip_image004 siječe parabolu samo u jednoj tački, ali ova prava nije tangenta date parabole u toj tački. Prava tangenta u toj tački je prava clip_image006 koja je normalna na pravu clip_image004[1] i prolazi tačkom clip_image008.

clip_image010

Slika  3.1  Položaj krive, sječice i tangente

Da bi smo došli do valjane definicije tangente uočimo sliku i sve što je na njoj nacrtano. Slika 3.2 sadrži jednu krivu clip_image012, dvije tačke clip_image014te pravu clip_image016koja spaja ove tačke. Vidimo da prava clip_image018 siječe krivu u obliku kriške lubenice te ćemo je nazvati sječica clip_image020. Kada hoćemo da odsjećemo što manji komad lubenice odnosno krive, mi ćemo postupiti tako da tačkuclip_image022pomjeramo prema tački clip_image024 preko ruba lubenice odnosno krive. Ako se tačka clip_image026, krijući se, približava tački clip_image024[1] kriška lubenice će se sve više smanjivati.

clip_image028

Slika  3.2  Sječica

Sječica će se mijenjati u odnosu na početni položaj, i kad tačka clip_image026[1] teži tački clip_image024[2], teži jednom graničnom položaju. Granični položaj sječice clip_image020[1] upravo će biti tangenta, tj. lubenica će ostati čitava.

Definicija 3.1.

Tangenta krive  u datoj tački clip_image030 zove se granični položaj sječice clip_image032 kada tačka clip_image034 ove krive teži  po krivoj ka tački clip_image030[1].

Ako se napravimo Englezi i želimo da ne odsječemo lubenicu tj. da nam tačka clip_image026[2] teži tački clip_image024[3] koeficijent smjera krive u tački clip_image024[4] jednak je koeficijentu smjera tangente krive u toj tački. Sve prethodno rečeno kažimo na jednom drugom (matematičkom) jeziku.

Posmatrajmo sliku, tamo ćemo vidjeti krivu clip_image012[1] sličnu prošloj krivoj i koordinatni sistem clip_image036. Ova kriva koju vidimo je grafik neprekidne funkcije clip_image038. U gornjem dijelu smo kazali da je kojeficijent smjera sječice koja prolazi tačkama clip_image040 koje imaju koordinateclip_image042, a clip_image044. Koordinate tačke clip_image026[3] lako se prepoznaju ako znamo da je clip_image046 odnosnoclip_image048, što se sa slike može vidjeti. Nadalje, znamo da je koeficijent smjera dat izrazom:

clip_image050

(2.1)

clip_image052

Slika  3.3  Sječica

Dakle koeficijent smjera tangente clip_image006[1] krive clip_image038[1] u tački clip_image054 jednak je graničnoj vrijednosti količnika clip_image056 priraštaja funkcije clip_image058 i priraštaja argumenta (nezavisno promjenjive clip_image060) clip_image062 kad on teži nuli.

Kao i u Poglavlju I (Matematička indukcija) mi definišemo neke sporedne pojmove, nesvjesno dolazimo do onoga čemu ovdje težimo da definišemo – to je prvi izvod funkcije. Zadnja tvrdnja koju smo napisali izraz 2.1 zovemo prvi izvod funkcije clip_image064 ili kraće izvod funkcije clip_image064[1], a kojeg obilježavamo sa clip_image066 (čitaj clip_image068 prim jednako clip_image070 prim od clip_image060[1]). Dakle prvim izvodom funkcije zovemo:

clip_image072

(2.2)

Na ovaj način smo definisali šta je koeficijent smjera krive u tački, odnosno koeficijent smjera tangente u tački, a istovremeno smo se upoznali sa osnovnom metodom određivanja koeficijenta smjera tangente u datoj tački krive, odnosno vidjeli smo jednostavni postupak konstruisanja tangente.

1.1.2 Srednja i trenutna brzina

Iz fizike nam je dosta stvari jasno kada spomenemo srednju i trenutnu brzin. Kada smo slušali predavanja iz fizike profesori su nam objašnjavali da je srednja brzina količnik priraštaja puta clip_image074 i vremenskog intervala clip_image076tj. priraštaja vremena za koje je tijelo prešlo put clip_image074[1], odnosno:

clip_image078

(2.3)

Znamo da je zakon puta skoro uvijek povezan sa vremenom clip_image006[2], pa je clip_image080. Ako posmatramo priraštaj puta clip_image074[2] koji je tijelo prešlo za clip_image082 možemo napisati kao clip_image084, pa nam je srednja brzina jednaka:

clip_image086

(2.4)

S gornjim izrazom uvijek se može izračunati neka srednja brzina koje se u toku nekog vremenskog intervala clip_image082[1] promijenila više puta. Međutim, ako posmatramo vremenski interval clip_image082[2] što manji promjene brzine za dati vremenski interval će biti sve manje. Kada pustimo da clip_image088 srednja brzina će postati trenutna:

clip_image090

(2.5)

Trenutna brzina (brzina u trenutku t odnosno clip_image092 je granična vrijednost srednje brzine u vremenskom intervalu clip_image094 kad clip_image096. Drugim riječima:

clip_image098

(2.6)

I ovdje vidimo da je trenutna brzina kretnja izvod dužine puta po vremenu. Na ovaj način (preko srednje i trenutne brzine) je Newton definisao izvod funkcije pa se čak može reći da je orginalna definicija izvoda upravo definisana preko srednje odnosno trenutne brzine. Možemo s pravom kazati: Izvod je brzina promjene dužine puta po vremenu.

 

1.2 Pojam IzvodA funkcije

Namjernim raspravljanjem o tangenti i srednjoj i trenutnoj brzini odnosno koeficijentu smjera tangente došli smo do pojma izvoda:

clip_image066[1]

(2.7)

Kao i kod definisanja trenutne brzine, u koliko je poznat zakon puta clip_image080[1], do pojma izvoda možemo doći bilo kakvim izračunavanjem brzine promjene neke veličine u toku vremena ako je poznat zakon ovisnosti te veličine od vremena.

Definicija 3.2.

Izvod funkcije clip_image100 po argumentu clip_image102 je granična vrijednost količnika priraštaja funkcije i priraštaja argumenta kad priraštaj teži nuli, tj.

clip_image104

Kada govorimo o izvodima često se spominje riječ od 3 slova – diferenciranje. Diferenciranje nije ništa drugo do granični proces kojim se dolazi do izvoda y’ funkcije clip_image068[1]. Za funkciju clip_image038[2] koja ima izvod u tački clip_image060[2] kažemo da je diferencijabilna u toj tački. Kada kažemo da je funkcija direfencijabilna na nekom intervalu clip_image106 to znači da je ista diferencijabilna u svakoj tački intervala.

Vidjeli smo i prije nego smo definisali izvod da ona (kako je na početku rečeno) ima veliku primjenu. Kada krenemo od geometrijske interpretacije izvoda do mehanike, preko fizike i td, sve do kompjutera video-igrica i flipera.

Razmotrimo jednu važnu osobinu izvoda funkcije, a to je diferencijabilnost i neprekidnost. Prije nego smo interpretirali izvod, pretpostavljali smo da nam funkcija mora biti neprekidna. Neprekidnost i diferencijabilnost tvore sljedeću teoremu:

Teorema 3.1.

Ako funkcija clip_image100[1] definisana na intervalu clip_image108 ima izvod u tački koja pripada tom intervalu odnosno clip_image110, (odnosno diferencijabilna je u datoj tački), tada je ona i neprekidna.

Dokaz:

Pretpostavka teoreme je da je funkcija diferencijabilna u tački clip_image060[3] tj. postoji clip_image112. Ako nam je clip_image114, tada možemo pisati:

clip_image116

Sada imamo, ako primijenimo granični proces na zadnji izraz:

clip_image118

Dakle, kada clip_image120, tada clip_image122. To znači da diferencijabilna funkcija clip_image038[3] je istovremeno i neprekidna u datoj tački.

Ovo je jedan od najvažnijih teorema koji se tiče Izvoda funkcije. Jednostavno bez ovog teorema ne bi smo mogli tako jednostavno “šetati” područjem izvoda. Gotovo kod svakog zadatka koji se tiče izvoda neke funkcije koristi se ovaj teorem.

Ako bi se pitali da li važi obrnut teorem, tj. da li je funkcija diferencijabilna ako je neprekidna, odgovor na ovo pitanje bio bi “NE”. Prije nego dokažemo ovaj teorem pročitajte sljedeću napomenu.

Napomena 3.1.

U matematici postoje dokazi za neke teoreme koje sprovodimo na taj način da nađemo bar jedan primjer koji opovrgava datu teoremu. Jednostavno pokazujući na jednom primjeru kontradiktornost teoreme mi je samim tim i dokazujemo.

Teorema 3.2.

Da li važi obrnut teorem prethodne Teoreme 2.1.

Dokaz:

Ovaj teorem ćemo dokazati navođenjem samo jednog primjera koji govori o tome da obrat ne važi. Posmatrajmo funkciju clip_image124. Ta funkcija je neprekidna na čitavom intervalu realnih brojeva. Graf funkcije daje je na slici 2.3. Sa slike se može vidjeti da jeclip_image126a clip_image128. Iz zadnjih izraza vidimo da je granična vrijednost količnika clip_image130za lijevu i desnu graničnu vrijednost po argumentu clip_image132različita, što znači da derivacija funkcije clip_image124[1] u tački clip_image134 nema jedinstven izvod. Drugim riječima funkcija clip_image038[4] u tački clip_image134[1] nije diferencijabilna. Dokaz teoreme je završen.

clip_image136

Slika  3.4  Grafik funkcije clip_image138.

Na osnovu prethodne dvije teoreme zaključujemo: svaka diferencijabilna funkcija ujedno je i neprekidna, dok svaka neprekidna funkcija nije uvijek i diferencijabilna. Pojam diferencijabilnosti je uži pojam od pojma neprekidnosti.

Matematika odabrana poglavlja konačno u digitalnoj formi


Naslovna stranica MATEMATIKAU nekoliko blog postova objavljivao sam dio tekstova iz matematike kojeg sam davno pisao (1996. god), većinom uz svijeću jer prošlo je nekoliko mjeseci od prestanka rata, dok se uspostavio elekto-prenosni sistem. Nažalost sva planirana poglavlja nisam napisao, šteta, jer danas se ne mogu vratiti u tu furku koju sam tada furo, pa nastaviti ovo po meni vrlo korisno djelo pisati. Po reakcijama koji su mi prijatelji i rijetki čitaoci davali, nije izgledalo loše. Isto tako, od kako sam objavio prve stranice  teksta na blogu, post se jako puno čita što potkrepljuju i statistike koje pratim na blogu. Isto tako u rubrici “Naj postovi” svi mogu vidjeti da se tu konstantno nalaze članci o matematičkoj indukciji. Danas sam konačno završio naslovnu stranu, i otkucao sav tekst koji planiram objaviti. Ostalo je jedno nedovršeno poglavlje koje sam odlučio da ga ne uključujem. Naslovnu stranu koju sam osmislio, sproveo je u djelo moj prijatelj Almir Štrkljević oko 1997 godine.

Naime, kod naslovne strane imao sam ideju da prikažem karikaturu Newtona i famozne jabuke, kao i karikaturu integrala \int f(x) dx. Svojom nadarenošću i sklonošću za crtanjem stripova i karikatura Almir je to vrlo zdušno prihvatio i potrudio se da onako, kako sam zamislio da to i nacrta. Ovom prilikom mu se od srca zahvaljujem.

Tekst sam prekucao i  nije prošao lekturu i korekcije pa sam svjesan da sadrži puno kako kucanih tako i gramatičkih grešaka. Pokušaću ih ispraviti prije nego što cijelokupni tekst stavim za download.

U ovom sabranom radu nalaze se tri poglavlja i to : Matematička indukcija, Funkcije i Izvodi. Knjiga sadrži oko 100 stranica A4 formata i veličine fonta 11.

U koliko nađete za shodno da vam može poslužiti ova knjiga slobodno je komentirajte i dajte svoje sugestije i primjedbe. Nažalost, ne namjeravam ovu knjigu obrađivati ponovo odnosno pisati naredno izdanje, jedini cilj mi je bio pretvoriti je u digitalnu formu.  Cjelokupan tekst može se pogledati ovdje.

Na kraju nekoliko fotografija rukopisa:

IMAG1022IMAG1023IMAG1024IMAG1028