My Pluralsight Course on “R Programming Fundamentals”

In the present world, when we are getting drowned in the heap of data, it is very important to use tools & techniques to get meaningful knowledge & information from data. This highlights the need of data science in the present world. Companies across the globe are using various tools of data science to get key insights from their business data and in-turn improving their bottom line. That’s why the  role of a data scientist is getting important with day by day. According to industry experts data scientist is considered at the sexiest job of 21st century.

R is a powerful and widely used open source software and programming environment for data analysis. R is one of the top 5 open source programming language in data science. R has been ranked 9 amongst all programming languages. R popularity is increasing rapidly day by day. R has become de-facto standard language among data analysts across the globe.  R is used by some of industry giants such as facebook, google, twitter, New York times for various data analysis activities such as data pre-processing, prediction, forecasting, data visualization etc. According to Dice Salary Survey , 2014 , R is among the highest paid IT skill in US.

I have recently authored a course on “R Programming Fundmentals” available on Pluralsight. This course will provide everything you need to know to get started with the R framework, and contains a number of demos to provide hands-on practice in order to become an efficient and productive R programmer. By the end of this course, you will also learn to play with data and to extract key information using various R functions and constructs.

Course contents ( Total content length : 06h 58m) :

Module 1 : Getting Started

This first module will provide you all information you need to know to get going with R framework. We will discuss the reasons of using R framework for data analysis projects.We will also go through the process of installing R and RStudio IDE on the local machine. By the end of this module, you will be familiar with R framework and things you can accomplish using R programming.

Module 2: Getting Help for R

This module will discuss ways to get help, if you come across any confusion or problem, while learning R programming.  By the end of this module , you will know where and how to get help if you run across cross any issue in your R endeavors.

Module 3: R : Variables & Operators

This module will cover some of the fundamental blocks of R programming such as variables, environments and operators. This module will also talk about vectorized operations and its benefits.

Module 4: Data Structures – Part 1

This module is the first part of data structure modules. In this module, We will discuss the need of different data structures. The part will cover various one-dimensional R data structures. By the end of this module, you will learn to create various one-dimensional data structures and to perform various operations on them.

Module 5: Data Structures – Part 2

This module is the second part of data structure modules. In this module, We will discuss several higher dimensional data structures such as data frames, matrices and arrays. By the end of this module, you will learn to create these data structures and to perform various operations on them.

Module 6 : R : Functions

This module is focused on various components of functions and their usage. By the end of this module, you will learn to create your own functions and how to use them in real world scenarios.

Module 7 : R : Flow Control

This module is focused on various flow control mechanism available in R. By the end of this module, you will learn to use various conditional statements and looping statements to control the flow of execution in R.

Module 8 : R : Packages

This module is focused on R packages. We will discuss some fundamental concepts related to R packages. By the end of this module, you will learn to load, install, remove and update R packages.

Module 9 : R : Import Data

This module is focused on various techniques to import data in R environment from a variety of sources. By the end of this module, you will learn to import CSV files, tabular files, XML files, excel files, built-in datasets and various databases.

Module 10 : Exploring Data With R

This module is focused on various techniques to explore a given dataset. By the end of this module, you will learn about various statistical indicators to analyze continuous and categorical data. You will also learn to use various R functions to explore the dataset and to extract various key insights.

I hope that this course will help you to generate interest in R programming as well as in the field of data science. This course will be followed by related courses on R, where I will cover different applications of R framework in the field of machine learning, data visualization, data analysis etc.

Please provide your valuable feedback to improve the content of the courses.

Tagged with: , , , , , , , ,
Posted in R

Learning Path : Machine Learning For Beginners

The modern era is a data-rich world. Data streams are available from unlimited number of resources. But raw data is not useful till you start getting knowledge from it. Machine learning is nothing but learning from data. So, various machine learning techniques can help you get the inherent knowledge or pattern in the available data set. There are plenty of great applications of machine learning such as

Spam detection, sentiment prediction, web document classification, market prediction, fraud detection, product recommendation, potential customer identification, weather prediction, character recognition, games, medical diagnosis …….the list is endless.

So, As you can see machine learning is a very powerful tool, and if you are also interested to learn and harness the power of machine learning, this blog post will be very helpful to you.

In this blog post, I will provide a learning path to understand various machine learning concepts. I have created several courses on Pluralsight targeting this subject. Based on these course, I have formulated this learning path for you.

Before going to the learning path itself.  lets answer one important question.

Who should follow this path ?

1. Those who want to learn the fundamentals of  various machine learning concepts without going into much mathematical details [ So no scary calculus, matrix algebra, probability terms]

2. Those who want to learn to build applications[ in various programming languages such as C#] based on various machine learning techniques

3. Those who want to learn the practical and real world implementations of machine learning techniques

4. Those who are planning to build their career in data analysis field.

5. Those who want to build great products using the open source machine learning framework ENCOG

 

Learning Path [ Total duration : Approx 10 Hours]

Level 1: Build a solid foundation by taking the first course

 Introduction to Machine Learning With ENCOG [ Total Duration : 2 hr 19 min]

Course Description : This course is focused on implementation and applications of various machine learning methods. As machine learning is a very vast area, this course will be targeted more towards one of the machine learning methods which is neural networks. The course will try to make a base foundation first by explaining machine learning through some real world applications and various associated components. In this course, we’ll take one of the open source machine learning framework for .NET, which is ENCOG. The course will explain how ENCOG fits into the picture for machine learning programming. Then we’ll learn to create various neural network components using ENCOG and how to combine these components for real world scenarios. We’ll go in detail of feed forward networks and various propagation training methodologies supported in ENCOG. We’ll also talk about data preparation for neural networks using normalization process. Finally, we will take a few more case studies and will try to implement tasks of classification & regression. In the course I will also give some tips & tricks for effective & quick implementations of neural networks in real world applications.

 

Level 2 : Learn advanced topics by taking the second course

Advanced Machine Learning With ENCOG [ 4 hr 11 min]

Course Description : Are you worried about your neural network model prediction accuracy? Are you not sure about your neural network model selection for your machine learning problem? This course will introduce you to more advanced topics in machine learning. The previous introductory course, “Introduction to Machine Learning with ENCOG 3,” laid out a solid foundation of machine learning and neural networks. This course will build upon that foundation for more advanced machine learning implementations. In this course, you will learn about various neural network optimization techniques to overcome the problems of underfitting and overfitting and to create more accurate predictive models. This course will also provide an overall picture of various neural network architectures and reasons for their existence. This course will be focused towards implementation of various supervised feed forward and feedback networks. During the whole course, we will be using open source machine learning framework ENCOG to implement various concepts discussed in this course. Although the implementations in this course are ENCOG-based, concepts discussed in this course are widely applicable in other frameworks or even in custom development.

Level 3 : Learn more advanced topics by taking the third course

Advanced Machine Learning With ENCOG – Part 2 [3 hr 41 min]

Course Description : Finding patterns in a multidimensional dataset has always been a challenging task, but self-organizing maps can simplify this process and can help to find interesting patterns and inferences. In this course, you will learn not only the fundamentals of self-organizing maps but also the implementation in a C# application using the ENCOG machine learning framework. In this course, you will also learn to use Hopfield networks in a pattern recall and reconstruction application. This course will also provide a real world case study on time series forecasting, where you will learn to forecast future behavior using historical values. The course also covers another very important aspect of machine learning: optimization. You will learn to solve optimization problems with the help of genetic algorithms. The concepts learned in this course are applicable for developers working in any other framework in any other language.

 

This 10 hour learning path will surely help you to understand the power of machine learning. And you will be able to implement various machine learning tasks easily and effectively. In fact, with each step, your confidence level will go up.

Hope this learning path will help you in your machine learning endeavors. Looking forward to your feedback.

 

Recommended Materials :

1. Programming neural networks with ENCOG 3 in C#, Jeff heaton

2. Artificial Intelligence for Humans , vol 1: Fundamental Algorithms, Jeff heaton

3. Introduction to math of machine learning, Jeff heaton

 

 

 

 

 

 

 

 

 

Tagged with: , , ,
Posted in Machine Learning, Technical

Basic SPA (Single Page Application) using Knockout JS

Hi All,

In this screencast, I will discuss the use of Knockout JS to create a basic SPA (Single Page Application).  The jsbin link is http://jsbin.com/eMaduPuw/1/edit

Posted in knockout, MVVM

Pluralsight Course on “Advanced Machine Learning With ENCOG”

Hello All Machine Learning Enthusiasts,

Recently, my new course on machine learning “Advanced Machine Learning With ENCOG ” got published on Pluralsight.com. Although the course is targeted for ENCOG users , but the concepts discussed in this course are widely applicable in other frameworks also.  This advanced level course is segregated in multiple parts.

This first part is available here.

Here is the table of contents for the first part of the course :

Module 1 (Course Introduction ): This module will provide an overview of this course and why one should take this course. This module will also describe the scope of this course. There is also a quick recap clip inside this module, which will help you to brush up the basics before delving into the advanced topics of machine learning.

Module clips are as follows :

  1. Introduction
  2. Course Scope
  3. Course Structure
  4. Quick Recap
  5. Summary

Module 2 (Network Tuning Part 1) : This module will be focused on various network tuning techniques to improve the accuracy of neural network predictive models. Network Tuning module has been divided into two parts. In the Part 1, We will look at network size tuning using pruning process. We will also discuss the need of such tuning. We will take a C# WPF application demo to understand network size optimization and how it can be used to solve the major problems of underfitting and overfitting.

Module clips are as follows :

  1. Introduction
  2. Outline
  3. Network Tuning
  4. UnderFitting And Overfitting
  5. Selection of layers and neurons
  6. Why Network Pruning ?
  7. About Pruning
  8. ENCOG support for Pruning
  9. Training ,Cross Validation and  Test dataset
  10. Demo Introduction
  11. Demo : XAML Code
  12. Demo : Core Steps-Shuffle, Segregate, Normalize And Prune
  13. Demo : Core Steps-Train
  14. Demo : Observations
  15. Summary

Module 3 (Network Tuning part 2) : In the first part, we looked at the requirement of network tuning and we talked in detail about two issues of learning process, first was underfitting and  second was overfitting. And we had discussed the network size optimization using the pruning process to address these two key issues.In this module, we will take another aspect of network tuning, which is to tune the training process itself. We will look at various strategies and how ENCOG machine learning framework can help us to implement these strategies.

Module clips are as follows :

  1. Introduction
  2. Outline
  3. Training Process Tuning
  4. ENCOG Training Strategies
  5. Greedy Strategy
  6. Demo : Greedy Strategy
  7. Hybrid Strategy
  8. Demo : Hybrid Strategy
  9. Reset Strategy
  10. Demo : Reset Strategy
  11. Required Improvement Strategy
  12. Demo : Required Improvement Strategy
  13. Smart Learning Rate and Smart Momentum Strategy
  14. Demo : Smart Learning Rate and Smart Momentum Strategy
  15. StopTrainingStrategy
  16. Demo : Basic Stop Strategies
  17. Demo : StopTrainingStrategy
  18. EarlyStoppingStrategy
  19. Demo : EarlyStoppingStrategy
  20. Summary

Module 4 (Neural Network Architectures Overview) : This module will provide an overall picture of various ENCOG Supported neural network architectures .This module will outline the reasons of co-existence of so many neural network architectures. Finally we will try to map different neural network architectures in different categories using an architectural map.

Module clips are as follows :

  1. Introduction
  2. Outline
  3. Type of Network Covered
  4. Why So Many ?
  5. Architectural Tree
  6. Summary

Module 5 ( Feed Forward Network – Part 1): This is the first part of the Feed forward networks, in which we will learn about linear neural networks. We will start with learning the concept of linear and non-linear problems. Then we will take two linear neural networks, Adaline and Linear Perceptron. We will also learn to implement these linear networks using ENCOG framework.

Module clips are as follows :

  1. Introduction
  2. Outline
  3. Feed forward Networks
  4. Input Output Mapping
  5. Linear Versus Non-Linear” Linear Neural Networks
  6. Adaline Network
  7. Adaline Network in ENCOG
  8. Demo : Adaline Network
  9. Perceptron Network
  10. Perceptron Network in ENCOG
  11. Demo : Perceptron Network
  12. Summary

Module 6 (Feed Forward Network – Part 2) : This is the second part of the Feed forward networks, in which we will learn about non-linear neural networks.We will take two non-linear neural networks, Multi Layer Perceptron and Radial Basis Function Network. We will also learn to implement these non-linear networks using ENCOG framework. We will also look at few of the real world applications of feedforward networks.

Module clips are as follows :

  1. Introduction
  2. Outline
  3. Non-Linear Neural Networks
  4. Multi Layer Perceptron
  5. Multi Layer Perceptron in ENCOG
  6. Demo : MLP Network
  7. RBF (Radial Basis Function) Network
  8. Radial Basis Function Calculation
  9. RBF Network Implementation
  10. XOR Problem using RBF
  11.   Basic RBF Network Implementation
  12. RBF Network in ENCOG
  13. Demo : RBF Network
  14. Applications of Feedforward Networks
  15. Summary

Module 7 (Feedback Networks) : This module will provide an overview of feedback networks and its properties. We will learn in detail about two simple recurrent networks in this module, first  one is the ELMAN network and second is JORDAN network. We will also look at real world applications of feedback networks. We will also take few C# demos to learn the implementation of feedback networks using ENCOG machine learning framework.

Module clips are as follows :

  1. Introduction
  2. Outline
  3. Feedback Network
  4. Elman Network
  5. Temporal XOR Problem
  6. Elman Network Training
  7. Elman Network in ENCOG
  8. Demo : Elman Network
  9. Jordan Network
  10. Jordan Network in ENCOG
  11. Demo : Jordan Network
  12. Applications of Recurrent Networks
  13. Summary

Module 8 (Course Summary) :This module will provide a quick summary to this advanced level course. We will also look at a short glimpse of the next course.

Module clips are as follows :

  1. Introduction
  2. Summary
  3. Next Course Glimpse
As this first part is focused towards supervised networks, the second part will be focused on unsupervised networks.
To all viewers, it would be great if you can give the feedback also, so that the feedback could be incorporated to improve future courses.

Finally, I would also like to mention two great books written by Jeff Heaton. This are great ebooks and must have for all ENCOG users.

  1. Programming Neural Networks with Encog3 in C#, 2nd Edition by Heaton, Jeff (Oct 2, 2011)
  2. Introduction to Neural Networks for C#, 2nd Edition by Jeff Heaton (Oct 2, 2008)
Posted in Machine Learning

Best Practices for WCF Programming – Part 1

WCF (Windows Communication Foundation) provides a framework, which greatly simplifies the communication needs for any application especially for enterprise level applications. It provides an abstraction level over various protocols such as SOAP, REST etc. WCF is widely used to leverage the benefits of SOA (Service Oriented Architecture).

In this blog post, I would like to highlight few of the best practices you can follow while programming WCF (on client as well as on Server side). This blog post is first in the series of “best practices for WCF programming”. This post will be focused towards client side practices.

Here are few best practices you can follow.

1. Use Async programming pattern: As you are making call to WCF services over a channel, its always a best practice to follow async pattern.If you are calling wcf services from an UI application, then async programming can help you to have responsive UI. Otherwise, you UI thread will be held till the execution of the WCF service.

Example 1

If you are using .NET Framework 3.5+, you can use Async version of your WCF webservice. All you have to do to attach a callback to the Completed event and then invoke the async version of WCF service

 var channel = new WCFServiceClient("ClientSideBindingName"); //Create a channel using WCF service client
 channel.MyWCFServiceCompleted += channel_MyWCFServiceCompleted; // Attach the callback to completed event
 channel.MyWCFServiceAsync(); // Invoke the Async version
 void channel_MyWCFServiceCompleted(object sender, MyWCFServiceCompletedEventArgs e) //Completed CallBack
        {
           //Use e.Result to get the result
        }

Example 2

If you are using .NET framework 4.5+, there is even easier way to have async pattern in your code. You can go to my earlier blog post “Asynchronous WCF service invoke with C# 5.0 Async And Await”

for more details.

2. Exception Handling :  As per Murphy’s law “It something can go wrong it will”, its always a good practice to have exception handling mechanism built into your codes. In WCF perspective, you should have exception handlers for at least following three types of exceptions

  • FaultException ( to catch exceptions related to your business logics)
  • CommunicationException (to catch exceptions related to underlying communication stack)
  • TimeOutException (to catch the timeout of your wcf invocation)

In the catch section, after performing necessary fallback work, you can abort the channel by using channel.Abort() method. Abort method is available on IClientChannel interface. So, if you are using a channel factory approach to create the channel, you will have to cast the channel to abort the connection such as

((IClientChannel)channel).Abort();

However,If you are using ServiceClient or ChannelFactory<T> where T also implements IClientChannel, then you can directly apply the Abort method to tear down the underlying communication channel such as

channel.Abort();

3. Reuse Service Contract Assemblies : In a larger program, if you are generating the client side code and configuration to consume WCF service using SVCUtil.exe (either through console or Add Service Reference method), a duplicate code of service contract will be generated in the client application too. For a larger application, you might not like this situation. Moreover, if there are certain dependencies (Such as constructor injection etc.) then you would be requiring the assemblies of service contract (or even implementation).

So, its a good practice to share the service contract assembly to the client application and then reuse those assemblies while generating artifacts from SVCUtil. This will help in avoiding the code generation for service side contractual information.

If you are using command line utility of SVCUtil then you can use /reference switch to re-use the shared service contract assembly. However, if you are using “Add Service Reference” GUI method , then under Advanced section you can put the check mark on “Reuse types in referenced assemblies”. You can even select specified referenced assemblies if you want.

4. Use MetadataResolver for dynamic applications:

Typically, we use SVCUtil (console or GUI) to generate endpoint configurations, which we can use later to create channels. However, if you are building a dynamic applications, and you want to create dynamic channel then you need to get endpoints through program. Using MetadataResolver.Resolve static method, you can get the list of endpoint exposed by a WCF service. For this you would just need the mex endpoint address (which implements IMetadataExchange interface). Then the MetadataResolver.Resolve will use the mex endpoint address and will return a collection of service endpoints. Then you can select the required service endpoint as per your requirement (based on address, binding or contract).  And using the selected endpoint you can create your channel.

Example :

 var endpoints = MetadataResolver.Resolve(typeof (IWCFService),
                                     new EndpointAddress("mex end point address"));//provide mex end point address
 var selectedEndPoint = endpoints.First(e => e.Binding.GetType() == typeof(BasicHttpBinding)); //sample query on list of service endpoints
 var factory = new ChannelFactory<IWCFService>(selectedEndPoint); //create channel based on selected endpoint
 IWCFService channel = factory.CreateChannel(); //create channel

Here in this blog post, I have mentioned only few of the best practices, stay tuned for subsequent posts.

Posted in Technical, WCF

Scalability : Challenges & Solutions for Enterprise Applications

For any enterprise level applications, scalability is of paramount importance. But scalability is associated with many challenges too, which needs to be addressed right in the design phase itself.  It could be very difficult to add scalability feature later in the development phase, because it needs a change in the overall architecture only.Before understanding the challenges let dig down the scalability term itself.

Typically, in an enterprise level application world, scalability is of two types.

1. Vertical Scaling : Where you increase the system capability (normally in terms of CPU, RAM etc.) which is responsible for service responses.

Suppose you have a IIS web server, which is hosting an ASP.NET application or WCF Service application. Initially, when 100 clients are accessing these applications(or services) and after sometime you have 10000 clients. So, now you have upgraded the system itself where this IIS web server is residing.

For such kind of scaling you need not to modify your application as such. So, no development cost is associated with horizontal scaling. But such horizontal scaling will not give you major benefits. Because you are still restricted with a single server.

 2. Horizontal Scaling :  Where you add more servers to improve the overall performance of the systems. Addition of servers will give you major scalability boost. And you can use load balancers to distribute the requests to different servers. If configured properly, request can be diverted to different servers and response can be given back to clients more efficiently. Load balancers could be of different types such as

  • Software Load balancers : such as NLB (network load balancers) which can distribute the load to different servers using programs
  • Hardware Load balancers : where load balancing is done at hardware level using network equipments such as routers

With the help of horizontal scaling, you can reap the benefits of distributed system.  Although you would like to add more and more severs to provide scalability with minimum configuration changes, but horizontal scaling comes with its own challenges. Lets discuss few of them here.

Challenges & Solution : The most important challenge is “Server affinity”. When a request is generated by a client then a session is created between the server and client to provide responses. So a particular client has a server affinity of a particular serving server. So, if you want to have more servers able to respond to client requests, you need to find a mechanism to avoid this server affinity.  So that any other server in the web farm can respond to the client requests. So, you need to find a workaround for session state.

There are multiple ways to do it. One widely used solution is to use “Sticky IP”, where the request of a particular client can be diverted to a particular server only by a load balancer. In case of WCF services, such behavior can be incorporated in the bindings (for example by disabling HTTP keep alive feature in basicHttpBinding or WebHttpBinding).

Think of an ASP.NET enterprise level application. You could use out of the box features provided by Microsoft to store the session states (such as InProc, StateServer, SQL Server). Where session states can be stored either in memory ( InProc) or it could be persisted to some SQL server database.  Another solution could be distributed cache mechanism. One excellent article on using distributed cache can be found here.

Whatever mechanism you adopt, but you have to have these things incorporated right from the design phase. Otherwise, it can substantially hamper your project life cycle in the long run.

Tagged with: ,
Posted in Enterprise Applications, Technical

Pluralsight Course on Introduction to Machine Learning with ENCOG

Hello everyone, My First course on machine learning is available now on pluralsight.com

If you are new to machine learning, and are scared of too much mathematics behind the scenes, this course is for you. This course will help you in not only understanding the basics of machine learning & neural networks, but also applying these concepts easily in your projects. The course uses C# and visual studio along with the open source machine learning framework ENCOG.

Concepts learned in this course will be applicable even if you are writing custom codes for your machine learning projects.

About the Course

This course focuses on the implementation and applications of various machine learning methods. As machine learning is a very vast area, we will target specifically the neural networks’ aspect of machine learning. The course will first build the foundations by explaining machine learning through some real world applications and various associated components. We’ll take a look at ENCOG, one of the open source machine learning framework for .NET. We will also learn to create various neural network components using ENCOG and how we can combine these components for real world scenarios. We will discuss data preparation for neural networks using normalization process as well as how to implement tasks of classification & regression.

Course Outline

Introduction to Machine Learning

  • Introduction
  • Why Machine Learning ?
  • Why This Course ?
  • Key Concepts
  • Spam Filtering
  • Course Structure

Applications of Machine Learning

  • Introduction
  • Internet
  • Financial Sector
  • e-Commerce
  • Process Industry
  • Others
  • Summary

Machine Learning Tasks

  • Introduction
  • Classification
  • Regression
  • Clustering
  • Summary

Introduction to Neural Networks

  • Introduction
  • Outline
  • Human Neuron vs Artificial Neuron
  • Neuron Computation
  • Neural Network Component : Neuron Types
  • Neural Network Component : Weights
  • Neural Network Component : Activation Function
  • Neural Network Component : Layers
  • Neural Network Computation
  • Model Creation
  • Model Training
  • Model Validation
  • Summary

Introduction to ENCOG 3

  • Introduction
  • Outline
  • About ENCOG
  • Why ENCOG ?
  • ENCOG Coverage
  • ENCOG Resources
  • Summary

Neural Network Components in ENCOG for .NET

  • Introduction
  • Outline
  • Data
  • Network
  • Training
  • Evaluation
  • XOR Problem
  • Demo : XOR problem with ENCOG 3 in C#

Propagation Training

  • Introduction
  • Outline
  • Propagation Training
  • Basic Concepts
  • Back Propagation Algorithm
  • Manhattan Update Rule
  • Quick Propagation Algorithm
  • Resilient Propagation Algorithm
  • Scaled Conjugate Gradient
  • Levenberg Marquardt Algorithm
  • Demo
  • Summary

Data Normalization

  • Introduction
  • Outline
  • Field Types
  • Need Of Normalization
  • Normalization and De-Normalization
  • Numeric Data Field Normalization
  • Numeric Data Field Normalization in ENCOG
  • Nominal Data Field Normalization
  • ENCOG Analyst
  • Summary

Case Studies (Classification and Regression Task)

  • Introduction
  • Outline
  • Case Study 1: Classification Task
  • Flow Chart 1
  • Demo : Case Study 1 : Shuffle 1
  • Demo : Case Study 1 : Segregate
  • Demo : Case Study 1 : Normalize
  • Demo : Case Study 1 : Create Network
  • Demo : Case Study 1 : Train Network
  • Demo : Case Study 1 : Evaluate Network
  • Case Study 2: Regression Task
  • Flow Chart 2
  • Demo : Case Study 1 : Shuffle 2
  • Demo : Case Study 2 : Segregate
  • Demo : Case Study 2 : Normalize
  • Demo : Case Study 2 : Create Network
  • Demo : Case Study 2 : Train Network
  • Demo : Case Study 2 : Evaluate Network
  • Summary

Link to the pluralsight course :

Introduction to Machine Learning With ENCOG

Tagged with: , , ,
Posted in Machine Learning, Technical
About Me


Software Architect, Developer & Pluralsight Author

Software Architect, Developer & Pluralsight Author, Twitter Handle :

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 107 other followers

Disclaimer
The opinions expressed herein are my own personal opinions and do not represent my current or previous employer's view in anyway.
Live Feed
Follow

Get every new post delivered to your Inbox.

Join 107 other followers