of code

Basic backpropagating neural network in Python

// Basic backpropagating neural network in Python

   1  
   2  import random
   3  
   4  class NN:
   5          def __init__(self, numInputs,  numOutputs, numLayers, numNodesPerLayer, learnRate=0.25, threshold=1, sigCoef=0.5):
   6                  self.weights = []
   7                  self.nodes = []
   8                  self.lambd = learnRate
   9                  self.a = sigCoef
  10                  
  11                  self.nodes.append([])
  12                  for x in range(numInputs):
  13                          self.nodes[0].append([0,0,threshold])
  14                  for x in range(numLayers):
  15                          self.nodes.append([])
  16                          for y in range(numNodesPerLayer):
  17                                  self.nodes[x+1].append([0,0,threshold])
  18                  self.nodes.append([])
  19                  for x in range(numOutputs):
  20                          self.nodes[-1].append([0,0,threshold])
  21                  
  22                  for x in range(numLayers+3):
  23                          self.weights.append([])
  24                  for x in range(numInputs):
  25                          self.weights[0].append(1)
  26                  for x in range(numLayers+1):
  27                          for y in range(len(self.nodes[x])*len(self.nodes[x+1])):
  28                                  self.weights[x+1].append(self.rand())
  29                  for x in range(numOutputs):
  30                          self.weights[-1].append(1)
  31  
  32          def rand(self):
  33                  return random.uniform(0,1)
  34          
  35          def sigmoid(self, inpt):
  36                  output = 1/(1+(2.71828183**((-self.a)*inpt)))
  37                  return output
  38                  
  39          def sigMyZ(self, nodeLoc):
  40                  d = self.nodes[nodeLoc[0]][nodeLoc[1]][0]
  41                  theta = self.nodes[nodeLoc[0]][nodeLoc[1]][2]
  42                  z = self.sigmoid(d + theta)
  43                  self.nodes[nodeLoc[0]][nodeLoc[1]][0] = z
  44  
  45          def passX(self, nodeLoc):
  46                  if nodeLoc[0]>0:
  47                          self.sigMyZ(nodeLoc)
  48                  
  49                  z = self.nodes[nodeLoc[0]][nodeLoc[1]][0]
  50                  lenOfNextLayer = len(self.nodes[nodeLoc[0]+1])
  51                  for nextNode in range(lenOfNextLayer):
  52                          self.nodes[nodeLoc[0]+1][nextNode][0] += (self.weights[nodeLoc[0]+1][(nodeLoc[1]*lenOfNextLayer)+nextNode]*z)
  53          
  54          def runOnce(self, inpt, returns):
  55                  output = []
  56                  
  57                  for x in range(len(self.nodes[0])):
  58                          self.nodes[0][x][0] = inpt[x]
  59                  
  60                  for x in range(len(self.nodes)-1):
  61                          for y in range(len(self.nodes[x])):
  62                                  self.passX([x,y])
  63                          
  64                  for x in range(len(self.nodes[-1])):
  65                          self.sigMyZ([-1,x])
  66                          output.append(self.nodes[-1][x][0])
  67  
  68                  if returns == 1:
  69                          return output
  70                  
  71          def backProp(self, y):
  72                  
  73                  for x in range(len(self.nodes[-1])):
  74                          z = self.nodes[-1][x][0]
  75                          self.nodes[-1][x][0] = 0
  76                          self.nodes[-1][x][1] = (z*(1-z)*(y[x]-z))
  77                          dTheta = self.nodes[-1][x][1]*self.lambd
  78                          self.nodes[-1][x][2] += dTheta
  79                          count = 0
  80                          for weight in range(x,len(self.weights[-2]),len(self.nodes[-1])):
  81                                  self.weights[-2][weight] += (dTheta*self.nodes[-2][count][0])
  82                                  count += 1
  83  
  84                  
  85                  for layer in range(2,len(self.nodes)):
  86                          lenOfThisLayer = len(self.nodes[(-layer)])
  87                          lenOfNextLayer = len(self.nodes[(-layer)+1])
  88                          for currentNode in range(lenOfThisLayer):
  89                                  z = self.nodes[-layer][currentNode][0]
  90                                  self.nodes[-layer][currentNode][0] = 0
  91                                  g = 0
  92                                  for nextNode in range(lenOfNextLayer):
  93                                          g += (self.nodes[(-layer)+1][nextNode][1]*self.weights[-layer][(currentNode*lenOfNextLayer)+nextNode])
  94                                  self.nodes[-layer][currentNode][1] = (z*(1-z)*g)
  95                                  dTheta = self.nodes[-layer][currentNode][1]*(self.lambd)
  96                                  self.nodes[-layer][currentNode][2] += dTheta
  97                                  count = 0
  98                                  for weight in range(currentNode,len(self.weights[(-layer)-1]),lenOfThisLayer):
  99                                          self.weights[(-layer)-1][weight] += (dTheta*self.nodes[(-layer)-1][count][0])
 100                                          count += 1
 101  
 102          def getLayers(self):
 103                  return self.nodes
 104  
 105          def getWeights(self):
 106                  return self.weights
 107  
 108

to python network error of backward py backpropagation neural propagation by monstradamus on Jul 30, 2008

DOM Parser Demo Code

//above class will search a movie/actor/producer name & will accordingly print other
//details
import javax.swing.text.html.parser.DocumentParser;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.util.*;
public class Movie_XML implements Movie
{

ArrayList<MovieDB> movies = new ArrayList<MovieDB>();

public ArrayList<MovieDB> searchByActorName(String nm,String key)
{
try
{
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
Document doc = docBuilder.parse("movie.xml");
NodeList nodeList = null;

if(key.equalsIgnoreCase("actor"))
nodeList = doc.getElementsByTagName("actor");
else if(key.equalsIgnoreCase("movie"))
nodeList = doc.getElementsByTagName("name");
else
nodeList = doc.getElementsByTagName("producer");

Node temp = null, parent=null;
NodeList childs = null;
for(int i=0;i<nodeList.getLength();i++)
{
temp = nodeList.item(i);
if(temp.getTextContent().equalsIgnoreCase(nm))
{
parent = temp.getParentNode();
childs = parent.getChildNodes();
MovieDB mDB = new MovieDB();
for(int j=0;j<childs.getLength();j++)
{
Node nd = childs.item(j);
if(nd.getNodeType() == Node.ELEMENT_NODE)
{
String name = nd.getNodeName();
//System.out.println(name);
if(name.equalsIgnoreCase("id"))
{
mDB.setId(nd.getTextContent());
}
if(name.equalsIgnoreCase("name"))
{
mDB.setName(nd.getTextContent());
}
if(name.equalsIgnoreCase("producer"))
{
mDB.setProducer(nd.getTextContent());
}
if(name.equalsIgnoreCase("director"))
{
mDB.setDirector(nd.getTextContent());
}
if(name.equalsIgnoreCase("music_director"))
{
mDB.setMusic_director(nd.getTextContent());
}
if(name.equalsIgnoreCase("actor"))
{
mDB.setActor(nd.getTextContent());
}
if(name.equalsIgnoreCase("actress"))
{
mDB.setActress(nd.getTextContent());
}
}
}
movies.add(mDB);
}
}
return movies;
}
catch(Exception e)
{
throw new CustomException("err in Searching by actor name",e);
}
}
}

//this class will call the above class by sending appropriate parmeters

import java.util.*;
import java.io.*;
public class XMLDemo
{
public static void main(String[] args)
{
try
{
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(ir);
while(true)
{
System.out.println("\n Enter the Choice : ");
System.out.println(" 1 : Search By Actor Name : ");
System.out.println(" 2 : Search By Movie Name : ");
System.out.println(" 3 : Search By Producer Name : ");
System.out.println(" 4 : Quit : ");
try
{
int ch = Integer.parseInt(br.readLine());
switch(ch)
{
case 1 :
System.out.println("Enter Actor Name : ");
String actorName = br.readLine();
search(actorName,"actor");
break;
case 2 :
System.out.println("Enter Movie Name");
String movieName = br.readLine();
search(movieName,"movie");
break;
case 3 :
System.out.println("Enter Producer Name");
String producerName = br.readLine();
search(producerName,"producer");
break;
case 4 :
System.out.println("Exiting");
System.exit(0);
default :
System.out.println("Invalid Choice !");
}
}
catch(Exception e)
{
System.out.println("Invalid Choice !");
}
}//end of while
}
catch(Exception e)
{
//e.printStackTrace();
throw new CustomException("err in main",e);
}
}

static void search(String name,String key)
{
try
{
ArrayList<MovieDB> movies = new ArrayList<MovieDB>();
Movie_XML obj = new Movie_XML();
movies = obj.searchByActorName(name,key);
int i =0;
System.out.println();
for(i=0;i<movies.size();i++)
{
MovieDB mDB = movies.get(i);
System.out.println("ID : "+mDB.getId());
System.out.println("Name : "+mDB.getName());
System.out.println("Producer : "+mDB.getProducer());
System.out.println("Director : "+mDB.getDirector());
System.out.println("Music : "+mDB.getMusic_director());
System.out.println("Actor : "+mDB.getActor());
System.out.println("Actress : "+mDB.getActress());
}
System.out.println(i+" Record Found!");
}
catch(Exception e)
{
throw new CustomException("err in byActor",e);
}
}
}

//this class will hold the details of the movie(id,name,---)

import java.util.*;
public class MovieDB
{
private String id,name,year;
private ArrayList<String> actor,actress;
private String director,producer,music_director;

public MovieDB()
{
actor = new ArrayList<String>();
actress = new ArrayList<String>();
}

public void setId(String id)
{
this.id = id;
}

public void setName(String name)
{
this.name = name;
}

public void setYear(String year)
{
this.year = year;
}

public void setDirector(String director)
{
this.director = director;
}

public void setProducer(String producer)
{
this.producer = producer;
}

public void setMusic_director(String music_director)
{
this.music_director = music_director;
}

public void setActor(String actor)
{
this.actor.add(actor);
}

public void setActress(String actress)
{
this.actress.add(actress);
}

public String getId()
{
return id;
}

public String getName()
{
return name;
}

public String getProducer()
{
return producer;
}

public String getDirector()
{
return director;
}

public String getMusic_director()
{
return music_director;
}

public ArrayList<String> getActor()
{
return actor;
}

public ArrayList<String> getActress()
{
return actress;
}
}

//movie interface

import java.util.*;
public interface Movie
{
public ArrayList<MovieDB> searchByActorName(String nm,String key);
}

to is example of the an one Above by sumit.tambekar on Apr 15, 2008

DOM Parser Demo Code

to is example of the an one Above by sumit.tambekar on Apr 15, 2008

Search DZone Snippets

Popular @ dzone.com

Related Tags

Never been to DZone Snippets before?

Basic backpropagating neural network in Python

DOM Parser Demo Code

DOM Parser Demo Code