Ai Lab Manual 6z3h5v

(<parameter-list>) )

38

The parameter list should be a list of variable symbols, so it is contained within () to indicate where the variable list stops. The body is going to be an actual call to another function, so it will be in parentheses. As an example, here is the way to define the square function: (defun square (x) (* x x)) SQUARE (square 2) 4 (square 3.5) 12.25 Conditional Statements if statements are defined as follows: (if <else>) The components in brackets can be any Lisp item that can be evaluated. If the returns any value other than nil, the component is evaluated and returned as the value of the if statement. Otherwise, if a nil is returned, the <else> component is evaluated and its value is returned. Here’s a definition of min for only two variables using an if statement: (defun min2 (x y) (if (< x y) x y)) MIN2 (min2 2 3) 2 (min2 3 2) 2 (min2 2 2) 2 A more complex conditional statement (similar to a case statement in C++) is the cond statement. cond allows multiple tests, and each test can be followed by a sequence of actions to be performed. Once a test is found to be true, the sequence of actions associated with that line is performed and the cond statement ends. If a test is found not to be true, the next test is tried. The general form is as follows: (cond ( ... ) ( ... ) ... ( ... )) Often times, the last case is used as the default case – its test is just t (true). As an example, let’s define absolute value with cond: (defun abs2 (x) (cond ((> x 0) x) (t (* -1 x)))) ABS2

39

(abs2 3) 3 (abs2 -3) 3 Recursive Statements Using if and cond, recursive statements are fairly straight-forward. The definition of factorial is as follows: (defun factorial (x) (if (> x 0) (* x (factorial (- x 1))) 1)) FACTORIAL (factorial 0) 1 (factorial 1) 1 (factorial 2) 2 (factorial 3) 6 Reading In Functions From Files: Definitions saved in a file can be loaded with the function load which has the syntax (load “filename”). (load "lab11.lisp") ;; Loading file lab11.lisp ... ;; Loaded file lab11.lisp T (factorial 2) 2 A comment can be added to a Lisp program by placing a semicolon on a line. Any text after the semicolon is considered a comment. Tracing and Debugging To trace the execution of a function, type (trace functionNameHere). To turn off tracing, type (untraced functionNameHere). To turn off tracing from all functions with one call, type (untrace). Given the function, (defun factorial (x) (if (> x 0) (* x (factorial (- x 1))) ; if x > 0, compute x * factorial (x-1), 1) ; else factorial(0) = 1 ) Here’s an example of a factorial trace: (trace factorial) (FACTORIAL) (factorial 3) 1. Trace: (FACTORIAL '3) 2. Trace: (FACTORIAL '2) 40

3. Trace: (FACTORIAL '1) 4. Trace: (FACTORIAL '0) 4. Trace: FACTORIAL ==> 1 3. Trace: FACTORIAL ==> 1 2. Trace: FACTORIAL ==> 2 1. Trace: FACTORIAL ==> 6 6 List Functions The more interesting functions are the built-in list processing functions. They can be broken down into three broad categories: Making a new list: cons, list, append Quote: Making some parts of the list not be evaluated. Selecting parts from a list: first, rest cons takes two arguments, an atom and a list, and adds the atom to the front of a list (ie it does a pre-pending of an element): >(cons 1 nil) (1) >(cons 1 (cons 2 nil)) (1 2) that each atom (i.e. each set of character symbols, i.e. each variable) is evaluated by the interpreter. The a is undefined before this statement, and thus evaluation of a will fail. In addition, that a list (set of parentheses) considers the first argument to be a function to call. So, if the interpreter got past a, the interpreter will try to call the function b. If b is not defined as a function, an error is raised. To work around this issue without having to calls cons multiple times, you can use the quote operator. A single quote is used to tell the Lisp interpreter that you don’t want a value evaluated, but that instead you want to use the value directly. So, to allow a to have the meaning a (as in the character a), you would type ‘a. Our failed example from above will work if re-written as follows: > (cons ‘a ‘(b c d)) // Note how the whole list is quoted by the ‘() operation (A B C D) The list function takes an arbitrary number of arguments (atoms or list) and constructs a new list with each of the arguments as an element in the list in their original form. >(list 2 3 4) (2 3 4) >(list ‘a ‘(a s d f)) (A (A S D F)) The append function takes an arbitrary number of lists as arguments and constructs a new list with each element from the input arguments. (append '(a b) '(c d)) (A B C D) (append '(a b) '(c d) '(d e)) (A B C D D E) (append '(a b) '(c d) '(d '(e f))) (A B C D D '(E F)) 41

The selector functions first and rest act much like hd and tl in Erlang. first takes a list as an argument and returns the first element of the list. rest takes a list as an argument and returns the list that is the original list without the first element. (first '(a s d f)) A (rest '(a s d f)) (S D F) (first (rest '(a s d f))) S Other Useful Atom and List Functions Other useful built-in functions include length, which takes as a single argument a list and returns the number of items in that list: (length '(1 2 3)) 3 (length '(1 2 (2 3))) 3 atom, which takes a single argument and returns whether or not that argument is an atom. listp, which takes a single argument and returns whether or not that argument is a list. (atom 'a) T (atom '(1 2 3)) NIL (listp 'a) NIL (listp '(1 2 3)) T (atom (+ 1 2)) // what is this actually doing? T nth which takes two arguments and essentially performs array indexing, with 0 as the first entry (nth 0 '(3 4 5)) 3 (nth 1 '(3 4 5)) 4 (nth 3 '(3 4 5)) // note that this is indexing outside of the list NIL

42

Week #11 Objectives: The lab this week will continue to introduce you to new features of Lisp. Its main focus is on variables, iteration, and arrays, and a little more on recursion: tail recursion. setq and setf Last week it was mentioned how an atom (a collection of one more character symbols) can represent a variable (we had to put an apostrophe in front of the atom to indicate an actual raw character or word). To set a variable to a particular value requires the use of the setq function. Think of setq as an assignment statement. This function has the following syntax: (setq atom value) As an example of it’s use, > (setq age 20) 20 > (setq legalToDrink (> age 21)) NIL > legalToDrink NIL > (setq age 25) 25 > (setq legalToDrink (> age 21)) T > legalToDrink T It is important to note that most functions acting on lists don’t actually change the list but instead return an updated version of the list. Using the setq function can allow updates to the list. > (setq mylist '(1 2 3)) (1 2 3) > (cons '0 mylist) (0 1 2 3) > mylist (1 2 3) > (setq mylist (cons '0 mylist)) // setq is essentially an assignment statement (0 1 2 3) // mylist has now essentially become 0::mylist > mylist (0 1 2 3) What if you wanted to replace the 1 at the front of (1 2 3) with a 0? We could do that that with: > (setq mylist '(1 2 3)) (1 2 3) 43

> (setq mylist (cons 0 (rest mylist))) (0 2 3) > mylist (0 2 3) An alternative allowed in Lisp for updating particular spots in a list is to use the setf function which allows updating of components of a list data structure. I tend to think of setf as an array updating function. The syntax is as follows: (setf (pointer-to-position-to-update) new-value) Interpret (pointer-to-position-to-update) loosely – you essentially need a function call here to put you over the right element to update – first and nth are good functions for doing that. Examples include: > (setq mylist '(1 2 3)) (1 2 3) > mylist (1 2 3) > (setf (first mylist) '0) 0 > mylist (0 2 3) > (setf (nth 0 mylist) '2) 2 > mylist (2 2 3) > (setf (nth 2 mylist) '4) 4 > mylist (2 2 4) Functions with Multiple Body Statements The body of a function can be composed of an arbitrary number of statements, each in its own parentheses. The value that is returned from a function defined as a sequence of statements is the value of the last function that is evaluated. The ability to call other functions in this way allows side effects to occur. These side effects are used primarily to update variables (both global and local variables, which will be defined better below). Here’s a (not very useful, but good example) function that makes use of multiple statements inside the function body: (defun addTwo (x) (setq y (+ 1 x)) (+ 1 y)) Note that this function, addTwo, has two statements that execute separately (one is not nested in the other). This function is equivalent to the C or Java function below.

44

int addTwo(int x) { y = x + 1; return y + 1; } When executed, we get the following results: > (addTwo 5) 7 Note that the value of the last statement that executes is what is returned -- the result of (+ 1 y). Local and Global Variables setq essentially defines global variables. A variable declared as an argument to a function or defined with a special let statement (discussed below) is considered as a local variable. Local variables will have priority over global variables when Lisp is looking to interpret a variable. As an example, look at the square function definition: (defun square (x) (* x x)) Even if there is an x variable declared at a higher level in the program, the only value that will be worked with is the argument ed in as the parameter x. When the square function finishes executing, the locally defined x goes out of scope (disappears). On the other hand, if a function uses a variable that it didn’t declare locally, it will examine all global variables to see if a matching one exists. If the global variable can’t be found or, if you try to read from it but it holds no value, the function fails. The function below: (defun y-plus (x) (+ x y)) will look for a global variable called y. Let Statement The let statement allows for explicit local variables to be defined within a function beyond the arguments. The syntax is as follows: (let (( <expr1>) ............... ( <exprn>)) ) Note that arbitrary numbers of local variable can be declared, and each set to a particular value (using an expression (the exprn slot)). If a value field is not present, the variable is set to nil initially. Note also that the parentheses in front of the let matches with the one after the body. This indicates those local variables can be only used within that body statement. If you need to make use of variables setup within the let definition in managing another later variable in the let definition, use let*. Otherwise, with just the plain let syntax, all variables are declared in parallel and they can’t build on each other. (defun test () (let ((a 1) (b 1)) (* a b))) (defun test2 () (let ((a 1) (b a)) (* a b))) ; THIS SHOULD FAIL (defun test3 () 45

(let* ((a 1) (b a)) (* a b))) > (test) 1 > (test2) // this failed because of the parallel issue *** - EVAL: variable A has no value The following restarts are available: USE-VALUE :R1 You may input a value to be used instead of A. STORE-VALUE :R2 You may input a new value for A. ABORT :R3 ABORT > (test3) 1 Iteration Techniques Last week, we saw that with cond and if statements, recursion was fairly simple to implement. Several of the TakeHome problems used recursion to define list operations – these all had the basic format of working on the head element and then calling a function recursively to process the remaining part of the list. The base case in list management was often times hitting the empty list. Other techniques besides recursion for performing an action multiple times are available in Lisp. The first such technique is dotimes, which acts much like a for loop. The syntax for dotimes is : (dotimes ( ) ) counter is a variable you provide which the system will end up setting to 0. The counter variable will be updated by one after each time the body is called. The limit variable should be set as a positive integer. You can in limit as a hardcoded value, as a variable, or as the result of an expression. result is an optional field that becomes a local variable. If it is present, its value will be returned as the result of the dotimes function. Otherwise nil will be returned. The body function will be executed until counter = limit (the body does not run when counter=limit, just up to that point). Here’s an example of a power(x,y) [xy, for y >= 0] function implemented recursively. (defun power2 (x y) (cond ((= y 0) 1) (t (* x (power2 x (- y 1)))))) Now, an example working iteratively using dotimes: (defun power3 (x y) (let ((result 1)) (dotimes (count y result) (setq result (* x result))))) The dolist function is similar to the dotimes function, but it iterates on the length of the target list ed in. Thesyntax is as follows: (dolist (

) ) result and body play the same role as they did previously. next-element is a local variable you provide which will be set to hold the current item the iterator is sitting on in the list. target-list should be set as the list you want to work within the argument list. An example of a function which can exploit dolist is counting the number of times an element appears in a list. Implemented recursively: (defun countRecursive (x mylist) 46

(if (= 0 (length mylist)) 0 (if (equal x (first mylist)) (+ 1 (countRecursive x (rest mylist))) (countRecursive x (rest mylist))))) And then iteratively: (defun countIterative (x mylist) (let ((result 0)) (dolist (e mylist result) (if (equal x e) (setq result (+ 1 result)) nil)))) Tail Recursion that tail recursion is an approach to recursion that has some nice efficiency properties and which suggests for many problems using an accumulator variable to push along the answer while it is being generated instead of generating the answers during the backtracking phase (when the recursion is unwinding from the base case). An example of a tail recursive power function and its trace is shown below compared against the same function written without tail recursion. Without tail recursion: (defun power2 (x y) (cond ((= y 0) 1) (t (* x (power2 x (- y 1)))))) > (power2 2 3) 1. Trace: (POWER2 '2 '3) 2. Trace: (POWER2 '2 '2) 3. Trace: (POWER2 '2 '1) 4. Trace: (POWER2 '2 '0) 4. Trace: POWER2 ==> 1 3. Trace: POWER2 ==> 2 2. Trace: POWER2 ==> 4 1. Trace: POWER2 ==> 8 8 With tail recursion: (defun power4 (x y) (power4Accumulator x y 1)) (defun power4Accumulator (x y currentAnswer) (cond ((= y 0) currentAnswer) (t (power4Accumulator x (- y 1) (* x currentAnswer))))) > (power4 2 3) 1. Trace: (POWER4 '2 '3) 2. Trace: (POWER4ACCUMULATOR '2 '3 '1) 3. Trace: (POWER4ACCUMULATOR '2 '2 '2) 4. Trace: (POWER4ACCUMULATOR '2 '1 '4) 5. Trace: (POWER4ACCUMULATOR '2 '0 '8) 5. Trace: POWER4ACCUMULATOR ==> 8 4. Trace: POWER4ACCUMULATOR ==> 8 3. Trace: POWER4ACCUMULATOR ==> 8 2. Trace: POWER4ACCUMULATOR ==> 8 1. Trace: POWER4 ==> 8 8

47

Composite Data Structures We have already seen how lists can be thought of as arrays. With the use of the nth function, it is easy to retrieve a single element from an arbitrary position out of a list. > (setq arrayOne '(1 2 3)) (1 2 3) > (nth 0 arrayOne) 1 > (nth 1 arrayOne) 2 > (nth 2 arrayOne) 3 To emulate a 2 dimensional array, the following code would be required: > (setq arrayTwo '((1 2 3) (4 5 6))) ((1 2 3) (4 5 6)) > (nth 0 arrayTwo) (1 2 3) > (nth 1 arrayTwo) (4 5 6) > (nth 0 (nth 1 arrayTwo)) 4 This could be very tedious for multi-dimensional arrays. Instead of using lists, an explicit array creation and component access syntax in Lisp is as follows: To create an array, use the syntax: (setq (make-array '( …))) As an example, the following code will create a 1-dimensional array of size 5 and a 2-d 3x3 array: > (setq vector1 (make-array '(5))) #(NIL NIL NIL NIL NIL) > (setq vector1 (make-array '(3 3))) #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL)) To read from an array spot defined in this way, use the aref syntax: (aref …) See below for an example. Array indexing starts with 0. To write into an array spot, use the setf syntax combined with an aref call ( how setf takes the explicit reference to the “spot” you are interested in writing into): > (setf (aref vector1 1 1) 25) 25 > vector1 #2A((NIL NIL NIL) (NIL 25 NIL) (NIL NIL NIL)) 48

> (aref vector1 1 1) // access first underlined item above 25 > (aref vector1 1 2) // access second underlined item above NIL It is possible to initialize an array with a value while it’s being created. If it isn’t initialized, all the internal values will be set to nil. > (setf anArray (make-array '(3) :initial-contents '(1 2 3))) #(1 2 3) > anArray #(1 2 3) > (aref anArray 2) 3

49

Week #12 Objectives: This lab introduces two final new Lisp features - a general repetition structure and ways of working with C++ struct/classlike data types. Another Looping Structure The two looping structures from last week were both dependent on known lengths (either a number you ed to the dotimes function or the length of a list ed to the dolist function). To me, these are essentially for loops. Another more general looping function is the do function. do has the following syntax: (do ( ( ) ( ) ... ( ) ) ( ) ) Note how the do syntax first consists of a set of variables. Each variable can be initialized, as well as specified with an optional update statement indicating how it should be updated after each iteration of the loop. The test is evaluated before each iteration and is the test for termination. If it es, the sequence of statements in body1 is executed, returning the value from the last expression evaluated. The body2 component consists of functions that are executed on every iteration until the termination condition is met. If you intend on udated values from an updateM statement in an updateN statement, where updateN happens after updateM, use do* instead of do (like we had to do with let and let*). Here’s an example function written in C++ that we can translate to Lisp to show the use of the do function. This function computes mn using a while loop: int power(int m, int n) { result = 1; exponent = n; while (exponent > 0) { result = result * m; exponent= exponent – 1; } return result; } The equivalent functions in Lisp using do: (defun power2 (m n) (do ((result 1) ; initialize result to 1 (exponent n)) ; initialize exponent to n ((= exponent 0) result) ; if exponent = 0, return the result (setq result (* result m)) ; otherwise, multiply result by m (setq exponent (- exponent 1)))) ; and subtract 1 from the exponent

50

You can further exploit the local variable update statements (not employed above) to simplify the function even further (defun power3 (m n) (do ((result 1 (* result m)) (exponent n (- exponent 1))) ((= exponent 0) result))) Composite Data Structures Structs in Lisp are much like their C++ counterpart s– they are defined as data structures made up of multiple data holders, with each data holder associated with a name. The defstruct function is used to define a struct. The syntax is (defstruct typename attribute1 attribute2 attribute3 …) > (defstruct employee firstname lastname sex id) EMPLOYEE A struct definition essentially defines a type and allows instances of those types to be created. Default constructors and accessors are available after a struct has been defined. The make-X syntax shown below can be thought of as a constructor for the struct, as it will return an instance of the type. > (setq employee1 (make-employee)) #S(EMPLOYEE :FIRSTNAME NIL :LASTNAME NIL :SEX NIL :ID NIL) > employee1 #S(EMPLOYEE :FIRSTNAME NIL :LASTNAME NIL :SEX NIL :ID NIL) > (setq employee2 (make-employee)) #S(EMPLOYEE :FIRSTNAME NIL :LASTNAME NIL :SEX NIL :ID NIL) > employee2 #S(EMPLOYEE :FIRSTNAME NIL :LASTNAME NIL :SEX NIL :ID NIL) Accessing attributes of an instance requires the syntax: (typename-field instanceName) > (setf (employee-id employee1) 123) 123 > (setf (employee-id employee2) 456) 456 > employee1 #S(EMPLOYEE :FIRSTNAME NIL :LASTNAME NIL :SEX NIL :ID 123) > employee2 #S(EMPLOYEE :FIRSTNAME NIL :LASTNAME NIL :SEX NIL :ID 456) > (employee-id employee2) 456

51

Values can be ed in to the “constructor” with the following syntax: (setq employee2 (make-employee :attribute1 value1 :attribute2 value2 …) > (defstruct employee firstname lastname sex id) EMPLOYEE > (setq employee2 (make-employee :id 789 :lastname 'bar :firstname 'foo :sex 'male)) #S(EMPLOYEE :FIRSTNAME FOO :LASTNAME BAR :SEX MALE :ID 789) > (employee-lastname employee2) BAR Default values can also be set up to be assigned by the constructor. This requires a small modification to the defstruct syntax, putting parentheses around each attribute that has an associated default value: (defstruct typename (attribute1 ‘value1) (attribute2 ‘value2) attribute3 …) > (defstruct employee firstname lastname (sex 'male) (id 1)) EMPLOYEE > (setq employee3 (make-employee)) #S(EMPLOYEE :FIRSTNAME NIL :LASTNAME NIL :SEX MALE :ID 1) > (employee-id employee3) 1 Finally, given that you’ve defined a new type, you can then test if variables are of that type with two different built-in functions: (typep variablename ‘typename) which tests whether a variable is of the type ‘typename (typep means typepredicate). > (typep employee3 'employee) T Alternatively, you can use a special type predicate which directly references the type name you defined. The syntax is: (typename-p variablename) > (employee-p employee3) T > (employee-p '(1 2 3)) NIL

52

Week #13 Objectives: In this lab you will be using Neural Networks as an alternative tool for decision-making modeling. The majority of empirical studies show that neural networks perform better than traditional linear methods and therefore have great potential to replace traditional forecasting and decision-making models. To model the networks Matlab software would be used under the Unix platform. *Matlab is a tool for doing numerical computations with matrices and vectors. It can also display information graphically. Refer to following site if you want more basic Matlab info: http://www.math.utah.edu/lab/ms/matlab/matlab.html, http://www.math.ufl.edu/help/matlabtutorial/ 1. the data. a. Go the class website. (http://www.buffalo.edu/~sbaek3/geo564.htm) b. Extract zip file. c. There are four data files: datann.xls, inputt1, targett1, inputs1, targets1. d. There is a script file called: script1.m The files correspond to the training (inputt1, targett1) and simulation (inputs1, targets1) components of the sample. The target outputs are included in separate files for modeling purposes. You can look at the list of your data by typing the ls command. To see the data contents type:more . 2. Under the Programs menu, run the X-Win32 6.1 program. a. Once you run it, you will see and icon in the bottom left of your desktop, next to the clock. b. Right click on it. c. Select Sessions. d. Choose UbUnix 3. . a. Use the same and as you do in the Ubunix system. 4. data files into your web directory (Unix directory). a. Open ftp S/W Start>Programs>FileZilla>FileZilla b. Type in following. - address : ubunix.buffalo.edu - : ubid - :ub p/w c. Click “Quick connect” 53

d. Drag and drop all files from your local folder in explorer to unix folder on fileZiller . 5. Running Matlab on X-terminal a. Type “Matlab &” in the terminal window. b. You would see the Matlab window comes up. 6. Set the path to your working directory. a. Type in ls and enter if you want to see file list on the command window on Matlab. b. cd if you want to enter into the folder. c. Edit it on your local computer and re it into unix directory If you want to edit script file. 7. The Script: a. The following code reads the training data set: input (independent variables) and target (mode choice selected). p=transpose(load('inputt1.txt')); t=transpose(load('targett1.txt')); Matlab reads all the inputs in a matrix format. Therefore matrix operations like transpose can be done to the inputs. The reason for transposing the data is to set it up in thecorrect structure needed by the neural network. b. The next set of functions define the Neural Network(NN) structure, the transfer functions between layers, the training algorithm, the number of neurons, the learning rate, the number of epochs, and the converging criteria. net=newff(minmax(p),[5,1],{'logsig','logsig'},'trainrp'); // Create a feed-forward backpropagation network net=init(net); net.trainparam.show=50; net.trainparam.lr=0.05; net.trainparam.epochs=5000; net.trainparam.goal=0.01; c. The following code defines the neural network and executes the training process. [net,tr]=train(net,p,t); d. Now that the network has been trained and the weights calculated to minimize the sum of square errors the simulation data set (validation data set/prediction data set) is read. ps =transpose(load('inputs1.txt')); ts=transpose(load('targets1.txt')); e. The inputs of the simulation data set are entered in the network and the outputs produced are calculated. y=sim(net,ps); f. The output is rounded in case the transformation function created a number that is not exactly zero or 1, the error is calculated and the outputs are printed on the screen. 54

yprime=round(y); e=ts-abs(yprime); ts yprime e error=sum(abs(e),1) g. Notice that this is just a loop that goes through the error vector which was the difference between the correct output and the predicted value. The variable “right” increase when error is equal to “0” to know how many times the NN predicted well. The number of correctly predicted is stored in the variable called right. The bigger “right” is the better prediction. right=0; for i=1: 400, if error(i) == 0 right= right + 1; end end right h. The following command displays the graph and closes the diary where the output of the process has been stored. plot(ts,y,’db’); hold off; diary off 8. Spend a couple of minutes understanding the script. For a complete list of function and command refer to the Matlab manual for Neural Networks Toolbox. (http://www.mathworks.com/access/helpdesk/help/toolbox/nnet/nnet.shtml ) 9. Running the script. a. To run the script type in the Command Window: script1 b. The script will execute. c. You will see the convergence process in the graph. This represents the training process, the time it takes the network to learn how to produce the given set of outputs. 10. Play with the number of neurons in the hidden layer. In the script the number of neurons is set to 5. Make sure you modify the graphs and output diary names. The diary can be openedusing any text editor. 11. You can change the training method, at this point which is set to trainrp, corresponding toresilient backpropagation. You can modify it to be: Gradient descent backpropagation: “traingd” Levenberg-Marquardt backpropagation: “trainlm” Gradient descent with adaptive learning rate backpropagation: “traingda” or some others. For a complete list refer to the Matlab manual for Neural Networks Toolbox (http://www.mathworks.com/access/helpdesk/help/toolbox/nnet/nnet.shtml ). Each method makes use of a different algorithm.

55

12. You can add additional hidden layers, by adding a third number to the newff command where between the 5 and 1 and add an additional transfer function for the layer. The number will indicate the neurons in that particular layer. e.g. 1) net=newff(minmax(p),[5,1],{'logsig','logsig'},'trainrp'); This network has two layers. The first layer has five logsig neurons and the second layer has one logsig neuron. e.g.2) net = newff([0 10],[5 1],{'tansig' 'purelin'}); The first layer has five tansig neurons and the second layer has one purelin neuron. e.g.3) net = newff([0 10],[5 3 1],{'tansig' 'tansig' 'purelin'}); The first layer has five tansig neurons, the second layer three transig neurons and the third layer one purelin neuron. 13. Test different topologies in of the number of hidden layers and the number of neurons in each hidden layer. Vary the training algorithm and given the results decide which network configuration predicts best. 14. Right click on the desktop and .

56

Week #14 Objectives:

57

58

59

60


61

62

63

64

65


66

67

68

Ai Lab Manual 6z3h5v

Overview 4q3b3c

More details 26j3b

Related Documents 171j1w

Ai Lab Manual 6z3h5v

Ai 3g6v5a

Ai 3g6v5a

Khalil Fong Ai Ai Ai Piano 1e4q3w

Lab Manual 4g5b3i

Lab Manual 4g5b3i

More Documents from "Mahreen Ilahi" 3t2f5a

Ai Lab Manual 6z3h5v

Khawateen Digest November 2018 - Pakibooks.site.pdf 2z4q5v

Kasahara Kunihiko - Origami Omnibus - Paper Folding For Everybody En 4t5h33

Japanese Gardens Ppt 2. 122h5d

Analisa Rugi Tegangan Dan Daya Pada Gi Betung Menggunakan Matlab d4m6e

Importance Of Communication In Hr Management 134o