Shriphani Palakodety » python

Listener Gets Another VAD

Shriphani — Mon, 09 Aug 2010 23:46:49 +0000

Over this summer, I wanted to make Listener Python only (there was a ton of needless applescript) and since my work @ VACCINE [VACCINE homepage] (more on this in a new post) didn’t leave much time for tinkering with things, I had to push this back as much as I could. I also added another voice activity detection algorithm which I believe works a lot better than what I had previously. And I also moved my project over to GITHUB.

The additions to Listener:

A new Voice Activity Detection algorithm [ link to pdf by Moattar and Homayounpour].
Skype4Py is still buggy on OS X with Python2.5 and it takes a nice solid dump (segfault) with Python2.6 so I am sure if the Skype part of the code works.
Python only. I removed the applescript portion from my code.

I have moved the entire code over to github: http://github.com/shriphani/Listener/ . The VAD algorithms can be seen in the file VAD.py.

This VAD also works by starting off with a base threshold for energy, power and an attribute called Spectral Flatness Measure. Luckily the paper had pseudocode so my DSP n00bishness wouldn’t get in the way of progress.

Anyway, to get this version of Listener running, download Listener.tar , untar it and run:

python2.5 audio_analysis.py

And you should be all set.

Bellman-Ford Algorithm’s Applications – Triangular Arbitrage

Shriphani — Sat, 03 Jul 2010 01:30:57 +0000

A very interesting application of the bellman-ford algorithm is arbitrage, essentially, given a table of currencies and their exchange rates, one needs to be able to figure out if we can start with a certain amount of money in one currency, exchange this amount for other currencies and end up with more money than what we had at first.

Example: 1 USD gives us 0.8 Euro and 1 Euro gives us 0.8 GBP and 1 GBP gives us 1.7 USD. So if I start with 1 dollar, I can exchange it for 0.8 Euro which can then be exchanged for 0.64 GBP and if converted back to USD we have 1.088 dollars.

So if rate_i_j is used to represent the amount of currency_j which we can get for 1 unit of currency_i, we observe:

rate_i_j * rate_j_k * rate_k_l * ….. * rate_z_i > 1

Invert this to get:

1/(rate_i_j * rate_j_k * rate_k_l * ….. * rate_z_i) < 1

and take lg on both sides:

lg(1/rate_i_j) + lg(1/rate_j_k) + ….. + lg(1/rate_z_i) < 0

So we observe that if we represent our table using a graph with lg(1/exchange_rate) as the weights, then the presence of a negative weight cycle is all that is needed to ensure we get more $$ than we started out with.

And of course, negative weight cycle detection is really easy with the bellman-ford single source shortest path algorithm.

This algorithm operates by the following dynamic programming equation:

distanceFromSource(v) = distanceFromSource(w) + weight(w, v)

When we set the distance of vertex ‘v’ from the source, we look at the edge (w, v) and observe that if we can get to ‘v’ by a shorter path through ‘w’, we discard the old distance and set distanceFromSource(w) + weight(w, v) as the new distance. This operation is called “Relaxing an edge”

Now, we only need to observe every edge a certain number of times. Precisely |V| – 1 times. Why? Well, consider a graph where the max out-degree is 1.

So, we have something like: v1 —-> v2 —–> v3 —–> v4 ——> …….. ——> v{n}. This is a directed graph with n vertices. If our source is v1, in the first of |V| – 1 iterations, we relax the first edge and fix the path to v2 (cannot get to v2 using a shorter path see?). In the second iteration, the path to v3 is fixed and continuing this we finish fixing the paths to the vertices |V| – 1 iterations (Remember, you relax every edge in each iteration).

To detect a negative weight cycle, finish relaxing all the edges |V| – 1 times. Now, carry the relax operation out once again. Since, all paths from the source to each vertex are guaranteed to be fixed by now, if you ever stumble upon a situation where you change distanceFromSource(v) for a vertex v, then a negative weight cycle starts and ends at v. The result of this is that a shortest path to v cannot be found, since for every path to v, you can make another trip about this negative-weight cycle and obtain an even shorter path.

So, I wrote a simple script for the Bellman-Ford routine and tested it using the USD, Euro, GBP example.

Here’s the Bellman-Ford routine:

#!/usr/bin/env python
#Author: Shriphani Palakodety

#Bellman Ford Implementation. Look it up on wikipedia.

distances = {}
parents = {}

def Initialize(graph, start):
”‘Prepares the graph for the bellman-ford algorithm’”
for vertex in graph.V:
if graph.E.has_key((start, vertex)):
distances[vertex] = 9999999e6

distances[start] = 0
parents[start] = None

def Bellman_Ford(graph, start):

Initialize(graph, start) #first initialize the graph

for i in xrange(len(graph.V) – 1):
for edge in graph.E.keys():
if (graph.E[edge] + distances[edge[0]]) < distances[edge[1]]:
distances[edge[1]] = graph.E[edge] + distances[edge[0]]
parents[edge[1]] = edge[0]

#one final check for negative weight cycles.

for edge in graph.E.keys():
if (graph.E[edge] + distances[edge[0]]) < distances[edge[1]]:
distances[edge[1]] = graph.E[edge] + distances[edge[0]]
parents[edge[1]] = edge[0]
return edge[1] #return here since, a negative weight cycle is detected

return None #return none on successful completion.

And the test itself:

!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: spalakod@purdue.edu

#Testing Arbitrage

#import graph
import bellman_ford
from math import log

#in the format cur1_cur2 = no. of units of cur2 for 1 unit of cur1

usd_euro = 0.8
euro_gbp = 0.8
gbp_usd = 1.7

#Nodes List
nodes = ["usd", "euro", "gbp"]
edge_dict = { ("usd", "euro") : log(1/usd_euro), ("euro", "gbp") : log(1/euro_gbp), ("gbp", "usd") : log(1/gbp_usd), ("euro", "usd") : log(usd_euro), ("gbp", "euro") : log(euro_gbp), ("usd", "gbp") : log(gbp_usd)}
#make a small graph to represent the currency network.

cur_graph = bellman_ford.Graph(nodes, edge_dict)

print bellman_ford.Bellman_Ford(cur_graph, "usd")

And when run, I get:

?(shriphani@Shriphani-Palakodetys-MacBook-Pro)?(533/ttys001)?(09:10P:07/02/10)?-
??(%:~/scripts)?- python arbitrage_test.py
usd
??(shriphani@Shriphani-Palakodetys-MacBook-Pro)?(534/ttys001)?(09:10P:07/02/10)?-
??(%:~/scripts)?-

So, there’s a negative weight cycle and if you kick off with some USD, you can get rich.

Get my routines here:

My code reads too much like pseudocode. Didn’t know a theory class corrupts so much.

Disjoint Set Data Structure

Shriphani — Thu, 20 May 2010 01:35:54 +0000

The last two weeks didn’t really offer a lot of challenges considering the semester is over and I didn’t grow a big enough pair to actually leave the practice rooms in TopCoder and go participate. So, I decided to revise some of the most interesting stuff I learned in my CS 381 class. And since I really liked the stuff we did with Disjoint Sets (not a lot of stuff, just kruskal’s algorithm but it still is pretty neat).We typically define 3 operations on disjoint sets:

MakeSet(x) : Create a set with the element ‘x’ in it.
FindSet(x) : Return the set that the element belongs to
Union(x, y) : Make a new set defined as : where and and destroy X and Y.

Implementation Using A Linked List:

Here each set is represented by placing its elements in the nodes of a linked list. In each node, we also store a pointer to the parent which contains the name of each set and some other information like the number of elements in the set, the name and so on.

Running Time For Each Operation:

MakeSet(x) : Constant Time

FindSet(x) : Return the parent that the parent pointer points to

Union(x, y) : Assume X is the set x resides in and Y is the set y resides in. Now, if we append the elements of X to Y, we would need to walk through X and set the parent pointers to Y. So, 1 union operation takes O(n) time.

Special Heuristics:

The Union(x, y) implementation gets a slight change here. When deciding which set to append to the other in the union operation, we append that set which has fewer elements to the other set. The advantage is that the walk through the list to change the parent takes lesser time.

Implementation Using A Tree:

We represent a set by a rooted tree where each node points to its parent (not parent -> children but the other way round). We define a special term here called rank. The rank of a set is an upper bound on the height of the tree. Why it is an upper bound will be evident soon.

Running Time Per Operation:

MakeSet(x) : Constant Time. Let x be a node whose parent is itself

FindSet(x) : O(log(n)) time. Basically need to go from x to the root.

Union(x, y): Constant time. We just make the root of either X or Y (the sets x and y belong to respectively) the parent of the other root.

Special Heuristics:

We use a heuristic here called path compression. When we run FindSet(x), we typically traverse the path from x to the root. With path compression, we basically make all nodes on this path the immediate children of the root. The advantage? Subsequent FindSet() operations on these nodes take constant time. This might modify the actual height (as you can see). BUT YOU DON’T CHANGE THE RANK HERE. Hence the rank is an “upper-bound” on the height. If we didn’t have the path-compression heuristic, the rank would have been the height.

So, the code follows. First the linked list implementation:

Here are the class definitions for the Nodes, the List and the Universe

valueNodeDict = {}

class Node():
”‘Represents a node of the linked list’”

def __init__(self, value, parent, next=None):
self.value = value
self.next = next
self.parent = parent
valueNodeDict[value] = self

def __str__(self):
return str(self.value)

class List():
”‘Represents the linked list itself’”

def __init__(self, name, value=None):
”‘Creates a set and sets head and tail to the appropriate nodes’”
self.name = name
self.count = 0
if value is None:
self.head = None
self.tail = None

else:
self.head = Node(value, self)
self.tail = self.head
self.count += 1

def __str__(self):
”‘Lists out all the elements’”
s = self.name + ": "
node = self.head
while node != None:
s += str(node) + ", "
node = node.next
return s + "\n"

def addElement(self, node):
”‘Add another node’”
self.tail.next = node
self.tail = self.tail.next
self.count += 1

def changeParent(self, newParent):
”‘Changes the parent of every node in the set’”
node = self.head
while node is not None:
node.parent = newParent
node = node.next

class Universe():
”‘Operations you can perform in the universe’”
def __init__(self, name="U"):
”‘Creates the universe where all your subsequent sets belong’”
self.name = name
self.setCount = 0
self.sets = []

def __str__(self):
s = self.name + ":\n"
for set in self.__sets:
s += "\t" + str(set) + "\n"
return s

def addSet(self, name=None, value=None):
”‘Adds a set to the universe’”
if name is None:
self.__sets.append(List("S"+str(self.setCount), value))
self.setCount += 1
else:
self.__sets.add(List(name, value))

U = Universe()

As you can see, I have a valueNodeDict dictionary in the implementation. The idea is that I should be able to use the values themselves in the operations and not the nodes.

Next, the operations themselves:

def MakeSet(x, name=None):
”‘Makes a new Linked List’”
U.addSet(name, x)

def FindSet(x):
”‘Find The Set This Node Belongs To’”
return valueNodeDict[x].parent

def Union(x, y):
”‘Destructively Perform The Union’”
if valueNodeDict[x].parent is not valueNodeDict[y].parent:
x_set = valueNodeDict[x].parent
y_set = valueNodeDict[y].parent

if x_set.count < y_set.count:
#x gets appended to y
y_set.count += x_set.count
x_set.changeParent(y_set)
y_set.tail.next = x_set.head
y_set.tail = x_set.tail
U.sets.remove(x_set)
else:
#y gets appended to x
x_set.count += y_set.count
y_set.changeParent(x_set)
x_set.tail.next = y_set.head
x_set.tail = y_set.tail
U.sets.remove(y_set)

Now, the tree implementation:

valueNodeDict = {}

class Node():
”‘Represents a node in a tree’”
def __init__(self, value, parent, rank):
self.value = value
self.parent = parent
self.rank = rank
valueNodeDict[value] = self

def __str__(self):
return str(value)

class Universe():
”‘The Universe where all sets sit’”
def __init__(self):
self.sets = [] #list of all root nodes

def addSet(self, root):
self.sets.append(root)

U = Universe()

And the operations:

def internalFindSet(x):
”‘Find The Root Of The Tree That Contains This Node. Uses path compression’”
if x.parent is not x:
x.parent = internalFindSet(x.parent)
return x.parent

def MakeSet(x):
”‘Make a new node whose parent is itself’”
a = Node(x, None, 0)
a.parent = a
U.addSet(a)

def FindSet(x):
”‘Returns the root of the tree which contains this value’”
x_node = valueNodeDict[x]
return internalFindSet(x_node)

def Union(x, y):
”‘Destructively Unite X and Y where x belongs to X and y to Y’”
x_set = FindSet(x)
y_set = FindSet(y)

if x_set.rank > y_set.rank:
y_set.parent = x_set
else:
x_set.parent = y_set
if x_set.rank == y_set.rank:
y_set.rank += 1

As an added exercise, I also threw in Kruskal’s algorithm for finding the Minimum Spanning Tree of a Graph. Here is my graph implementation which just consists of an edge-list and a vertex-list:

import heapq
from disjoint_set2 import *

class Vertex:
def __init__(self, value):
self.value = value

def __str__(self):
return self.value

class Edge:
def __init__(self, vertex1, vertex2, weight):
self.vertex1 = vertex1
self.vertex2 = vertex2
self.weight = weight

def __str__(self):
s = "Connects: " + str(self.vertex1) + " and " + str(self.vertex2) + "\tWeight: " + str(self.weight)
return s

class Graph:
def __init__(self, V, E):
self.V = V
self.E = E

I decided to create a small graph with nodes: ‘a’, ‘b’, ‘c’, ‘d’ and ‘e’. The code to do that:

characters = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

vertices = []
edges = []

for char in characters:
vertices.append(Vertex(char))

Next, I decided to connect every vertex to every other vertex using edges whose weights are in increasing order as follows:

Edge from ‘a’ to ‘a’ has weight 0

From ‘a’ to ‘b’ we get 1

From ‘a’ to ‘c’ we get 2

and so on, you get the idea. The plan was to get a verifiable result straight away.

for vertex1 in vertices:
for vertex2 in vertices:
edges.append(Edge(vertex1, vertex2, i))
i += 1

G = Graph(vertices, edges)

Now, we prepare the required data structures for this algorithm. We need a priority queue. Python 2.6.5 ships with a heapq module. Using this module, we can maintain a heap in an array and the desired “bubble up” and “bubble down” operations are performed by the heapq module’s routines. As it is known to mankind, the root of any heap contains the element with the smallest key (assuming the heap is storing (key, value) pairs and is a min-heap). So, we finally have:

def kruskal(G):
heap = []

for edge in G.E:
heapq.heappush(heap, (edge.weight, edge))

T = [] #this contains all the edges in the tree

# run makeset on all the vertices

for vertex in G.V:
MakeSet(vertex)

while heap:
min_edge = heapq.heappop(heap)[1]
if FindSet(min_edge.vertex1) is not FindSet(min_edge.vertex2):
# perform a union and add this edge to the Tree
T.append(min_edge)
Union(min_edge.vertex1, min_edge.vertex2)
return T

So, I return a list of edges in the MST. When I run this on the graph created above, I get:

(shriphani@Shriphani-Palakodetys-MacBook-Pro) (556/ttys000) (09:03P:05/19/10) -
(%:~/scripts) > python kruskal.py
Connects: a and b	Weight: 1
Connects: a and c	Weight: 2
Connects: a and d	Weight: 3
Connects: a and e	Weight: 4

Which when checked is the actual MST.

Analysis

Assume that we have n makeset operations out of m overall operations, with the special heuristic we use, anytime a list is chosen for appending to another list, we observe that this list has to have fewer elements than the other list.

So, this is the pattern we have:

If there is one element in the list and this list is chosen for appending to the other list, then the resulting size would be at least 2
If the current size is 2 and we append this list to another list, the resulting size will be at least 4
Once we append a list of size 4 to another list, the resulting list would have a size of 8.

So, we observe that in 3 append operations, we approached a size of 8. So, in lg(8) operations, we approached size 8. So, we would approach size ‘n’ (the kruskal() routine obtains the MST on a connected graph at this stage) in lg(n) operations.

Also, there need to be n-1 union operations since the Universe finally contains just 1 set with all vertices in it (assuming you have a connected graph). There need to be n-1 union operations for the universe to approach this state. So, a final running time is O(n * lg(n)) for this.

Now, if the graph is pretty sparse, as in 5 vertices and a single edge in the entire graph, the other operations would dominate. So, the actual running time is

O(m + n*lg(n))

With the tree based structure, our course didn’t cover the analysis but we were told that the running time was a cool O(m * alpha(n)) where alpha(n) <= 4 for most circumstances.

The code can be obtained at:

In this post I used material from Cormen-Leiserson-Rivest-Stein’s amazing book (It is the best book I’ve ever read. Please go get a copy. You won’t regret it). And of course, stuff from Professor GNF’s CS 381 class. It is the best CS course I’ve taken thus far.

Listener Gets a VAD

Shriphani — Thu, 21 Jan 2010 01:15:23 +0000

So, the beginning of the 4th semester in the midst of losers and overachievers and this sem promises to set my a$$ on fire. As usual, I plan to continue working under Dr. Kihara this sem so that should be interesting. Anyway, I decided to improve upon what listener offered and decided to add a VAD algorithm to it. I initially chose the algorithm by moattar and homayounpur and decided that I ended up with too much to do (it might certainly be a good candidate for later, when I have more time for example). Hence, I decided to snoop around for something simpler and found this paper which seemed small and had a sort of ever changing threshold for successive frames. The paper was authored by S.Milanovic, Z. Lukac and A. Domazetovic. I still don’t think I got it exactly right though. The paper mentioned that they used counters to mark frames as silence based on what the previous frame was and I had to come with a counter upper bound for myself and finally chose to go with 10 as a good counter for such stuff. i.e. even if a particular frame doesn’t make it beyond its threshold, it still will be marked as active if the previous frame was active. This is done to accommodate situations where we end up reducing our volume at the end of a word / sentence.

Finally to decide whether there was speech on an overall level, I look for at least 3 instances of 18 consecutive frames being marked as active (just random picks, 18 frames allows 8 active frames and 10 additional for the counter we have and 3 looked like a good candidate at the end when I spoke my own name out).

And as a final measure, I also ensure that the overall intensity beats 48 dB so that someone trying to have a conversation with me is only recognized.

Finally, I made the switch from GeekTool to Growl as this thing kept taking a solid amount of real estate and since I have one 23” monitor and a 15” monitor, this thing is positioned outside the real estate of my laptop’s display. Growl seems like a better candidate overall and since I could get growl bindings to build on my machine finally, I think I should let growl handle this.

So, the only places where my VAD implementation (or my mod of whatever was in that paper) doesn’t seem to work is in surroundings with a piano (in our dorm’s lobby for example), v inconvenient but whatever, probably some time in the future, I will begin understanding DSP and spectral analysis well enough to come up with a simple VAD algorithm (as opposed to implementing something straight from a paper without any understanding of what is going on). Anyway, here is the updated script, it seems to do well recognizing speech in sort of silent settings:

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Tool to aid those with noise cancellation headphones

import pyaudio
import wave
import sys
import struct
import numpy
import time

Growl_exists = True

try:
import Growl
except ImportError:
print "No Growl"
Growl_exists = False
pass

skype_on_call = False
notifier = 0
if Growl_exists:
notifier = Growl.GrowlNotifier(‘Listener’, [‘Attention’, ‘test’])
#notifier.applicationName = ‘Listener’
notifier.register()

def record():
”‘Records Input From Microphone Using PyAudio’”
duration = 3 #record for 1 second. Pretty long duration don’t you think
outfile = "analysis.wav"

p = pyaudio.PyAudio()

inStream = p.open(format=pyaudio.paInt16, channels=1, rate=44100,input=True, frames_per_buffer=1024)

out = []
upper_lim = 44100 / 1024 * duration #upper limit of the range we record to. 44100 / 1024 sized chunk * 5 seconds

for i in xrange(0, upper_lim):
data = inStream.read(1024)
out.append(data)

#now the writing section where we write to file
data = ”.join(out)
outFile = wave.open(outfile, "wb")
outFile.setnchannels(1)
outFile.setsampwidth(p.get_sample_size(pyaudio.paInt16))
outFile.setframerate(44100)
outFile.writeframes(data)
outFile.close()
analyze()

def analyze():
if skype_on_call:
print "\n"
print "Skype Call In Progress"
print "Listener On Hold"
return
inFile = wave.open("analysis.wav", "rb") #open a wav file in read mode
thresh = 1000 #establish a minimum threshold
max_samp = 0

decision = [0]

#for i in xrange(441):

inactive_counter = 0

vals = inFile.readframes(inFile.getnframes()) #read in 30 samples
len(vals)
results = struct.unpack("%dh"%(inFile.getnframes()), vals) #unpack to get the samples
results = [abs(x) for x in results]

#now we need to pull 30 samples at a time (30 samples = 1 frame).

for i in xrange(4404):
frame = results[30*i: 30*(i+1)]
print frame
new_thresh = (thresh * (1 – (2.0 ** -7))) + ((2 ** -8) * max_samp)

#check how many samples go above this new threshold
count = 0

for j in frame:
if j > new_thresh:
count += 1
if count / 30.0 >= 0.9 : #need it to beat 90%
#frame is a candidate for speech
decision.append(1)

else:
#this is where we use a counter based implementation for labelling inactiveness
if inactive_counter < 10 and decision[-1] == 1: #we ignore silence for 10 runs
decision.append(1)
inactive_counter += 1
else:
inactive_counter = 0
decision.append(0)

#update the threshold and the max sample values
thresh = new_thresh
max_samp = max(frame)

#final check for characterization as speech, we use another counter
active_counter = 0 #since the inactive counter will cause silence to be recognized as speech, we only consider speech as
print decision
final_num = 0
for val in decision:
if active_counter >= 18:
print "Speech!"
final_num += 1
active_counter = 0
if val == 1:
active_counter += 1
else:
active_counter = 0

results = [x ** 2 for x in results]
intensity = 20 * numpy.log10(numpy.sqrt(sum(results)/inFile.getnframes()))

if final_num >= 3 and intensity > 48:
if Growl_exists:
notifier.notify(‘Attention’,‘Listener’, ‘Speech Detected Nearby’)
else:
print "Speech Detected Nearby!\nSomeone might be calling you"
inFile.close()

if __name__ == "__main__":
f = open("skype_Status", "r")
for new_line in f:
if new_line == "PROGRESS":
skype_on_call = True

if skype_on_call:
analyze()
else:
record()

Anyway, it would be really convenient if I could find something about VAD algorithms and improve listener to work better for my dorm room settings. It is doing a pretty good job already but there is always scope for improvement.

As always, my solutions need to be convoluted and over here, I make use of applescript to check if there’s a skype call going on or not, so yeah, you can find all that here.

Screenshots etc available on Listener’s new home: http://shriphani.com/blog/listener/.

The One PITA

Shriphani — Sun, 29 Nov 2009 05:22:15 +0000

Well, it is thanksgiving break and I was so far having a decent semester, straight As in all exams (a perfect score in economics – not that I should be proud of it or anythin) and then terror strikes. Or well whatever the college version of a cataclysm is. I managed to f’kin ruin (misunderstand) the spec on a project and I am in danger of throwing away a coveted 4.0 GPA which would have been a great reward for the long hours of study I have put in + a retooling of my schedule so I have the multitasking capability of a mule and those $$ my parents spend so their son can enjoy a pain free life in a first world country and try to make them proud. Well, as it happens, I managed to (or at least I think – the scores are not yet out) misunderstand a spec AAAAARRRGGHH! In a datastructures course, I mastered AVL & Red-Black trees, spent hours trying to tweak my implementations, did well on the exam and managed to blow it when it came to reading a text file and filling an array. I just wonder how I even pull this stuff off. With Grad School apps coming in 2 years, what will I have to show – a carelessness in even reading specs seriously that puts doubts on the efficacy of my research methodology, I just hope I don’t cause major problems for myself.

Well, in case this doesn’t make sense, I managed to misunderstand a technique to populate an array with data (the data structs would work with this but oh no, in my interest to take the maximum from this course, I devoted long hours to getting the data structs right). There is a very good chance that the part I screwed up would end up being insignificant but that is not the point. The point is that once again my grade is going to shuttle between the first two letters of the english alphabet.

Anyway, in all this self hatred that I have been building up for myself, I have managed to learn some cool stuff in Dr. Kihara’s lab. The work there is pleasant, I can feel good boasting about it and when I talk to my friends’ parents, I can make them believe I am going to find a solution to poverty in 4 years and find a cure for cancer in my spare time (you can see I am not popular).

However, a weird question I was dealing with was that most of the stuff I have written for my work is in Python and it would be cool if I could call it from Java since there are a bunch of people in the lab who use it. I am not looking for something complicated, just want to call a bunch of methods from a Python module. JPype and Jython seem to the things I should be looking for but with my awesome constraints (Python 2.6 should be supported, It should make coffee etc), I will need to use my Uber-GOOGLE-SKILLZ.

Anyway, this blog has managed to get to pagerank 0 (I will interpret that as the pagerank o loner being relevant ) and I am now a suggestion on Google (yay! my plan for world domination is in full swing!)

And I love this Charlie dude who bites his bro’s finger, as for kanye, well even the prez thinks he’s a jackass:

Tinkering With A New Project

Shriphani — Fri, 18 Sep 2009 16:46:57 +0000

During the vacation this summer, I began working on creating an app that would help me respond to calls of attention when my auditory sensory capabilities were compromised courtesy the noise cancellation capabilities of my Bose headsets. Well, I managed to make a few mods to that script, used a touch of applescript (thank god OS X apps are scriptable) and introduced a bunch of new behaviors:

-> When a Skype call is in progress, the app stops listening.

Ok, not a bunch, just one. Also, this is not exactly an app you should be using since it relies too much on quirks in my own computing environment. Anyway, for more details you can head over to http://shriphani.com/Shriphani_Website/Listener.html.

So, a few screenshots:

Apart from that, I also wrote a protein function matching script as part of my research this semester. I will be putting it up soon. Wow, I have been more productive in these three weeks than all of last year.

Bio-Informatics

Shriphani — Fri, 04 Sep 2009 17:20:22 +0000

It has been an amazing first week at college here. First, I began working with Prof Kihara and got to see a whopping 160 thousand (!) annotations. The coolest part is that I got to see a few protein function prediction algorithms (I get to code! Yippee!). Well, at one point I had to whip up my own factorial function (since I can’t use Python2.6 which has a math.factorial courtesy lab machines). Well, I modded a bit of the code I found at http://en.literateprograms.org/Factorials_with_prime_factorization_%28Python%29 (which helped me a lot, thanks). And then I mixed it up with my miller rabin implementation and had a bit of fun :D.

So the slightly modded version of the factorial script should look like this.

First DSP Attempts

Shriphani — Fri, 26 Jun 2009 13:51:02 +0000

Well, since my last post on detecting calls of attention using my microphone, I have been paying attention to DSP since it seems to be one cool topic to spend 3 months on. So, I decided to begin reading the dspguide and found some cool stuff which I decided to tinker with. After reading about convolution, I decided to implement some basic filters that would help me amplify, add echoes and so on. First, implementations of convolution, the input side algorithm and the output side algorithm:

The input side algorithm:

def convolute_inside(impulse_response):
global output_signal
global input_signal
len_out_signal = len(input_signal)+len(impulse_response)-1
output_signal = [0 for x in xrange(len_out_signal)]
for i in xrange(len(input_signal)):
for j in xrange(len(impulse_response)):
output_signal[i+j] = output_signal[i+j] + input_signal[i]*impulse_response[j]

The output side algorithm:

def convolute_outside(impulse_response):
global output_signal
global input_signal
len_out_signal = len(input_signal)+len(impulse_response)-1
for i in xrange(len_out_signal):
output_signal.append(0)
for i in xrange(len_out_signal):
for j in xrange(len(impulse_response)):
#print i, j
if not (i-j)<0 and not (i-j)>len(input_signal)-1:
output_signal[i] += impulse_response[j] * input_signal[i-j]

Next, using appropriate filters, we can add echoes and amplify the input signal. So, we first need to read in a wav file. Using my previous script, that should be simple:
Reading a wav file:

def readWavFile(input):
inFile = wave.open(input, "rb")
sample_rate = inFile.getframerate()
total_samples = inFile.getnframes()
vals = inFile.readframes(total_samples)
inFile.close()
return struct.unpack("%dh"%(total_samples), vals)

This next function adds an echo to the input signal:
Add an echo:

def add_echo():
”‘Amounts to scaling and shifting the delta function and then adding it to a delta function’”

#considering the intensity of the echo to be 60% of that of the original signal and delayed by 1000 samples:

impulse_response = [0 for x in xrange(1003)] #shifted and scaled delta function + delta function
impulse_response[0] = 1
impulse_response[-1] = 0.6
convolute_inside(impulse_response)

The above function considers that an echo occurs a 1000 samples after the current one and with an intensity 6 tenths of the original signal. Since testing this becomes a serious pain, I decided to test my echo function using a different input signal and impulse response (echo is 6/10 of the original intensity and 4 samples away).

def add_new_echo():
”‘Amounts to scaling and shifting the delta function and then adding it to a delta function’”

#considering the intensity of the echo to be 60% of that of the original signal and delayed by 4 samples:

impulse_response = [1,0,0,0,0.6] #shifted and scaled delta function + delta function
convolute_inside(impulse_response)

input_signal = [1,2,3,4]
#print input_signal
add_new_echo()
print output_signal

The output of this is:

mouse-den% python convolution.py
[1, 2, 3, 4, 0.59999999999999998, 1.2, 1.7999999999999998, 2.3999999999999999]

The impulse response for amplifying a signal would be a scaled delta function, so:

def amplify():
”‘Make the impulse function a scaled delta function’”

impulse_response = [2]
convolute_inside(impulse_response)

The code to write to a wave file should be pretty straightforward:

def writeWavFile(out):
outStream = wave.open(out, "wb")
outStream.setnchannels(1)
outStream.setsampwidth(2)
outStream.setframerate(44100)
data = ""
for i in xrange(len(output_signal)):
data += struct.pack(‘h’, output_signal[i])
outStream.writeframes(data)
outStream.close()

So, here is the test wave file: test.wav

And the amplified wav file: output1.wav

Now, to the part where we try to figure out if a signal contains another signal.

Turns out, to do that, you just need to obtain the cross-correlation of the input signal and the waveform we already have.

So, the code to do this for a signal that goes like [1,2,3,4] is:

def cross_correlate(input_file=""):
”‘Cross correlate, obtain the graph and find the peak’”

global input_signal
global output_signal
#input_signal = record() #this procedure reads in the signal we need to find
input_signal = [1,2,3,4,11,0,0,1,10,5,2]
impulse_response = [1,2,3,4] #read in our signal
impulse_response.reverse()
convolute_outside(impulse_response)
print output_signal

This results in a signal that looks like:

[4, 11, 20, 30, 64, 44, 26, 15, 43, 52, 44, 26, 9, 2]

So, I had to figure out an algorithm to detect the peak and I found one on stackoverflow.com and it goes like this:

for i in xrange(len(output_signal)-1):
travel = output_signal[i+1] – output_signal[i]
rise = output_signal[len(output_signal)-1] – output_signal[0]

if (travel/rise) > 1:
#print output_signal[i]
peak_options[output_signal[i]]=i

return peak_options[max(peak_options.keys())]

In other news, I am going to work in Prof. Kihara’s bio-informatics laboratory this fall and I hope it works out.

WAV Files, Spring Semester, Research Hopes, IPL,

Shriphani — Tue, 26 May 2009 04:21:47 +0000

UPDATE 02/13/2010: Most recent version of this script is now moved to: http://shriphani.com/blog/listener.

EDIT: An updated version of this script along with tools to improve the user experience can be obtained at http://shriphani.com/Shriphani_Website/Listener.html

After an looooong time, I’ve decided to put finger on keyboard (I think that sounds stupid). Considering that I now use BOSE headphones which cut me off from the outside world when I am listening to anything (I use the triport headphones; not the Quietcomfort), it has been a bit hard to respond to all the calls for attention over here (no one usually wants me to pay attention and that’s how it works best). So I decided that it would be better if I could use the mic on my mac to check if someone was calling me. This is the first time I have tinkered with .wav files and I am sure that I am doing loads of things wrong. First, I decided to use PyAudio, PortAudio’s Python bindings, to record audio from the microphone, save it to a wav file and then open it and analyze etc. So with help from the Examples that come bundled with PyAudio, here is the code to record from the inbuilt microphone:

Recording:

def record():
”‘Records Input From Microphone Using PyAudio’”
duration = 1 #record for 1 second. Pretty long duration don’t you think
outfile = "analysis.wav"

p = pyaudio.PyAudio()

inStream = p.open(format=pyaudio.paInt16, channels=1, rate=44100,input=True, frames_per_buffer=1024)

print "recording has begun"
out = []
upper_lim = 44100 / 1024 * duration #upper limit of the range we record to. 44100 / 1024 sized chunk * 5 seconds

for i in xrange(0, upper_lim):
data = inStream.read(1024)
out.append(data)

#now the writing section where we write to file

data = ”.join(out)
outFile = wave.open(outfile, "wb")
outFile.setnchannels(1)
outFile.setsampwidth(p.get_sample_size(pyaudio.paInt16))
outFile.setframerate(44100)
outFile.writeframes(data)
outFile.close()

Then, I opened the wav file and read the first 2000 values from it and obtained the root mean square amplitude and then obtained the intensity of sound using the following snippet:

Analyzing

def analyze():
inFile = wave.open("analysis.wav", "rb") #open a wav file in read mode
sample_rate = inFile.getframerate()
total_samples = inFile.getnframes()
fftLength = 128
fft_num = (total_samples/fftLength) -2
vals = inFile.readframes(2000)
results = struct.unpack("%dh"%(2000), vals)
results = [x**2 for x in results]
intensity = 20 * numpy.log10(numpy.sqrt(sum(results)/2000))
if (intensity > 55):
print "Someone might be calling you"
curtime = time.localtime()
print "Current Time: %d:%d:%d"%(curtime[3], curtime[4], curtime[5])
print "Intensity: "+str(intensity) + " dB\n"
inFile.close()

I chose 55 dB because well 55 dB seems to be the right intensity of sound you would hear if you were conversing with someone 1 meter away.

The next thing to do would be to repeat this action over and over again. I decided to use something like:

while True:
record()
analyze()
sleep(2.0)

I am not sure what went wrong there but when it ran the second time it gave me an “internal PortAudio Error” which pissed me off. However, using BASH to handle the endless loop worked and I could achieve the desired functionality using something like:

while [ "true" ]
do
python audio_analysis.py
sleep 2
done

This might be the wrong way to go about it but it works at least…..

Also, I thought growl would be something cool to have and I decided that I would go out there and get it use Growl to notify me but for some screwed up reason I cannot build Growl’s Python bindings using the Enthought Python Distribution which I use. I can however build it using Python 2.6 (and I still use the Numpy that comes with EPD). I get errors like:

running install
running build
running build_py
running build_ext
building '_growlImage' extension
gcc -arch i386 -arch ppc -isysroot /Developer/SDKs/MacOSX10.4u.sdk -g -L/usr/local/lib -L/Library/Frameworks/Python.framework/Versions/4.3.0/lib -bundle -undefined dynamic_lookup build/temp.macosx-10.3-fat-2.5/growlImage.o -o build/lib.macosx-10.3-fat-2.5/_growlImage.so -framework Cocoa
ld: in /Developer/SDKs/MacOSX10.4u.sdk/Library/Frameworks/Python.framework/Versions/4.3.0/lib/libz.1.dylib, file is not of required architecture for architecture ppc
collect2: ld returned 1 exit status
lipo: can't open input file: /var/tmp//ccNgltEc.out (No such file or directory)
error: command 'gcc' failed with exit status 1

I think that I am unable to generate a universal binary there and as a result I can’t use Growl. Anyway, I have two screens and I can leave a terminal window open on one of those to see what’s going on in the surroundings. So sample run:

cm92:scripts shriphani$ ./repeat.sh
Someone might be calling you
Current Time: 11:55:22
Intensity: 56.9166929341 dB

Someone might be calling you
Current Time: 11:55:33
Intensity: 72.6820018669 dB

Someone might be calling you
Current Time: 11:55:51
Intensity: 56.7505666696 dB

Someone might be calling you
Current Time: 11:55:54
Intensity: 55.571208569 dB

Someone might be calling you
Current Time: 11:55:58
Intensity: 60.0388858371 dB

Someone might be calling you
Current Time: 11:56:1
Intensity: 56.3460220002 dB

These results were obtained in the following situations:

The TV running.
My mom calling me.

Anyway, in other news, I managed to end up with a GPA of 3.85 overall thanks to a series of mistakes towards the end of the semester and lost the 4.0…….. it is depressing, but I’ll just put that behind me for now.

And I’m also trying to find a spot in Prof Kihara’s computational bio lab….. I hope I get to do some research next semester.

The spring was not full of disappointment, I got to meet some awesome professors in the honors seminar (in which I skipped most of the student presentations except the one I was supposed to speak in). I got to meet Prof. Wagstaff who has a prime number named after him, I got to meet Prof Kihara and others.

Congrats to the Deccan Chargers for their excellent performance in the Indian Premier League. Thanks for rewarding our unyielding support by bringing the trophy to Hyderabad.

Now I’ve got to go and entertain myself with Combat Arms.

UPDATE: The script can be obtained at: Script to Record+Analyze and Script to Repeat action.

Hebb’s Rule

Shriphani — Mon, 09 Feb 2009 00:58:30 +0000

This post is slightly psychology influenced. Well, in the Psychology class I have been taking this semester (Introduction To Cognitive Learning), I was taught about Neural Networks and a certain Hebb’s Rule which allows a network to remember a previous configuration and use this configuration to interpret new information. We use the following model to represent a cell:

1. A cell (neuron) has only two activation states: On or Off.

On: Cell has high firing rate. (High number of action potentials fired in unit time).
Off: Cell has low firing rate.

2. Cell weights are reciprocal. Weights symbolize the size of the synapse between two cells. Greater size = greater strength.

3. If cells fire simultaneously, they develop positive weights. The active cells (activation = on) inhibit the inactive cells (develop negative weights.

4. The network organizes itself based on sensory input. And new sensory info is interpreted by previously developed weights.

5. The network updates itself one at a time.

6. The activation of a cell can be determined by the following formula:

1 if ∑w_ija_j > 0
0 otherwise

The weights lend a sort of memory to the network since weights influence the interpretation of subsequent sensory input.

Based on these rules, I wrote something that simulated a network that implemented the Hebb’s rule.

First, we need to describe a neuron. Our neurons represent an uppercase letter of the english alphabet. We also need a way to represent the weights with each of the other neurons.

So a basic class to describe a neuron:

class Neuron:
def __init__(self, a, weight_dict):
”‘A Represents The Cell’s Content”‘

self.content = a #what letter of the alphabet a cell represents
self.weights = weight_dict #only contains contents of each neuron.
self.state = 0 #activation state initially on.

def __str__(self):
return "Activation: "+str(self.state)+"\nWeights: "+str(self.weights)

Now, the network has a collection of neurons (26 in our case which signify each letter of the alphabet). Hence, the init method for the neuron class:

def __init__(self):
self.neurons = []
self.flush = {} #weight calculator while updating activities
self.possibilities = []

for char in string.uppercase:
self.flush[char] = 0

for letter in string.uppercase:
weights = copy.copy(self.flush)
weights.pop(letter)
a = Neuron(letter, weights)
self.neurons.append(a)

Now that we have a network that is populated, we need a method that receives input and figures out the changes in the weights between cells (or the strength of the connection between cells). This method is then fed by another method that figures out the overall change in the weights and computer which cells are active:

def recvInput(self):
a = raw_input("Sensory Interface: ") #Get a word

while a != "QUIT":
b = list(a)
for i in xrange(len(b)):
for neuron in self.neurons:
char = b[i]
if neuron.content == char:
neuron.state = 1
reqd_list = b[0:i]+b[i+1:]
for char in string.uppercase:
if char in reqd_list:
neuron.weights[char]+=1
else:
if neuron.weights.has_key(char):
neuron.weights[char]-=1
else:
continue

self.checkInfo()
self.possibleInfo()
print "The possible interpretations of this input might be anagrams of the subsets of: \n"
print self.possibilities
a = raw_input("Sensory Interface: ")

def checkInfo(self):
output = []
possibilities = {}
for neuron in self.neurons:
if neuron.state == 1:
for info in neuron.weights.keys():
self.flush[info] += neuron.weights[info]
print self.flush

for neuron in self.neurons:
if self.flush[neuron.content] > 0:
neuron.state = 1
else:
neuron.state = 0

for char in self.flush.keys():
self.flush[char] = 0

def possibleInfo(self):
self.possibilities = []
for neuron in self.neurons:
if neuron.state == 1:
self.possibilities.append(neuron.content)

Then we run this network with:

words = Network()

words.recvInput()

Before I run this, let me mention that this thing only accepts uppercase letters and breaks if a letter is repeated in a word. This is because neurons rarely have their own axon connected to their own dendrite (neurons are not connected to themselves).

So, a sample run:

tark-b-183:scripts shriphani\> python hebb.py
Sensory Interface: HELP
{'A': -4, 'C': -4, 'B': -4, 'E': 3, 'D': -4, 'G': -4, 'F': -4, 'I': -4, 'H': 3, 'K': -4, 'J': -4, 'M': -4, 'L': 3, 'O': -4, 'N': -4, 'Q': -4, 'P': 3, 'S': -4, 'R': -4, 'U': -4, 'T': -4, 'W': -4, 'V': -4, 'Y': -4, 'X': -4, 'Z': -4}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'H', 'L', 'P']
Sensory Interface: LOSER
{'A': -9, 'C': -9, 'B': -9, 'E': 7, 'D': -9, 'G': -9, 'F': -9, 'I': -9, 'H': -2, 'K': -9, 'J': -9, 'M': -9, 'L': 7, 'O': 0, 'N': -9, 'Q': -9, 'P': -2, 'S': 0, 'R': 0, 'U': -9, 'T': -9, 'W': -9, 'V': -9, 'Y': -9, 'X': -9, 'Z': -9}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'L']
Sensory Interface: HOMELY
{'A': -12, 'C': -12, 'B': -12, 'E': 9, 'D': -12, 'G': -12, 'F': -12, 'I': -12, 'H': 4, 'K': -12, 'J': -12, 'M': -1, 'L': 9, 'O': 4, 'N': -12, 'Q': -12, 'P': -6, 'S': -6, 'R': -6, 'U': -12, 'T': -12, 'W': -12, 'V': -12, 'Y': -1, 'X': -12, 'Z': -12}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'H', 'L', 'O']
Sensory Interface: LOSER
{'A': -17, 'C': -17, 'B': -17, 'E': 13, 'D': -17, 'G': -17, 'F': -17, 'I': -17, 'H': -5, 'K': -17, 'J': -17, 'M': -9, 'L': 13, 'O': 8, 'N': -17, 'Q': -17, 'P': -11, 'S': 1, 'R': 1, 'U': -17, 'T': -17, 'W': -17, 'V': -17, 'Y': -9, 'X': -17, 'Z': -17}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'L', 'O', 'R', 'S']

So we observe that in the first case, four neurons were activated. The word “LOSER” led to H and P being deactivated because the synapse weakened. The next input “HOMELY” causes H and O to activate because O began developing positive weights with other cells and when LOSER was submitted as input and developed a strong enough connection when it was seen in another sensory input. When LOSER is flashed again, it leads to H being forgotten and causes R and S to activate.

Now, a particular case which (I think) indicates the use of this “learning” technique is when we are playing scrabble. Assume that I have words such as NEAR in my memory and when I see N and E on a board, I should be able to complete these words. Watch:

Sensory Interface: NEAR
{'A': 3, 'C': -4, 'B': -4, 'E': 3, 'D': -4, 'G': -4, 'F': -4, 'I': -4, 'H': -4, 'K': -4, 'J': -4, 'M': -4, 'L': -4, 'O': -4, 'N': 3, 'Q': -4, 'P': -4, 'S': -4, 'R': 3, 'U': -4, 'T': -4, 'W': -4, 'V': -4, 'Y': -4, 'X': -4, 'Z': -4}
The possible interpretations of this input might be anagrams of the subsets of: 

['A', 'E', 'N', 'R']
Sensory Interface: NE
{'A': 1, 'C': -6, 'B': -6, 'E': 4, 'D': -6, 'G': -6, 'F': -6, 'I': -6, 'H': -6, 'K': -6, 'J': -6, 'M': -6, 'L': -6, 'O': -6, 'N': 4, 'Q': -6, 'P': -6, 'S': -6, 'R': 1, 'U': -6, 'T': -6, 'W': -6, 'V': -6, 'Y': -6, 'X': -6, 'Z': -6}
The possible interpretations of this input might be anagrams of the subsets of: 

['A', 'E', 'N', 'R']
Sensory Interface:

Well, this semester, I have already been taught some insanely great stuff. I have a bunch of exams coming up. Great scores will be the perfect way to make an awesome semester even better.

The script can be downloaded here.
The material here was used from Professor Greg Francis’ notes on Neural Learning.