Shriphani 'PSP' Palakodety » python

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.

Post’s Machine Emulator

Shriphani — Sat, 17 Jan 2009 19:42:35 +0000

I was bored as usual and since Combat Arms has begun to slip in my list of pastimes, I decided to write a Post’s Machine Emulator as described in the booklet by V. A. Uspensky titled “Post’s Machine” ( Amazon Link

This machine has a tape (infinitely long) and the reel has cells which can be marked or unmarked. I decided to represent a marked cell with a “1″ and an unmarked cell as “0″.

The head of this machine can move both ways and can mark and at the same time remove the mark from the other side.

The machine can be instructed using the syntax:

number, action, jump

The position of the head is indicated by a structure \”[]\” around the cell. Example:

Initial Stage
.....[0], 0, 0, 0, 0, .....

I used the “…..” to indicate that the remnant cells are all unmarked.

So here are the Head and Tape classes:

class Cell:
”‘Class describing the cell of a tape’”

def __init__(self, mark=0):
”‘Each cell is unmarked by default’”
self.mark = mark

def setMark(self):
self.mark = 1

def remMark(self):
self.mark = 0

class Tape:
”‘Class describing the infinite reel in the machine’”

def __init__(self):
”‘Each tape has an infinite number of cells both ways’”
self.reel = []
for i in xrange(5): #we display only the required elements at a time
cell = Cell()
self.reel.append(cell)

def __str__(self):
printstr = "….."
for cell in self.reel:
printstr += str(cell.mark)+","
printstr += "….."
return printstr

class Head:
”‘Class describing the head’”

def __init__(self, tape, position=0):
self.position = position
self.tape = tape

def moveLeft(self):
if self.position != 0:
self.position -= 1

else:
extension = []
extension.append(Cell())
self.tape = extension + tape.reel

def etchMark(self):
self.tape.reel[self.position].setMark()

def remMark(self):
self.tape.reel[self.position].remMark()

def moveRight(self):
if self.position == len(self.tape.reel) – 1:
self.tape.reel.append(Cell())
self.position += 1

def getPosition(self):
return self.position

Then comes the Machine class which takes a tape as an argument. So that you can insert your own tape or use the default tape:

class Machine:
”‘Class describing the Post Machine’”

def __init__(self, tape):
self.tape = tape
self.head = Head(tape)
self.commands = {}

def parseInstruction(self, number, action, jump):
”‘Instruction is of form "[number, action, jump]"’”
self.commands[number] = [action, jump]

def beginExecution(self):
instruction = 0
action = self.commands[instruction][0]

while action != "exit":
if action == "<":
self.head.moveLeft()
elif action == ">":
self.head.moveRight()
elif action == "mark":
self.head.etchMark()
elif action == "unmark":
self.head.remMark()

print self
instruction = self.commands[instruction][1]
action = self.commands[instruction][0]

return

def __str__(self):
”‘This returns tape with the head displayed’”
a = str(self.tape)
posn = self.head.getPosition()
temp = "….."
for i in xrange(len(self.tape.reel)):
if i == posn:
temp += "["+str(self.tape.reel[i].mark)+"], "
else:
temp += str(self.tape.reel[i].mark) + ", "
temp += "….."
return temp

Next comes a function that reads an input file for instructions:

def run(input_file):
infile = open(input_file, ‘r’)
b = infile.readlines()
for instruction in b:
try:
splits = instruction.split(",")
number = int(splits[0].strip())
action = splits[1].strip()
if action == "exit":
a.parseInstruction(number, action, 0)
else:
jump = int(splits[2].strip())
a.parseInstruction(number, action, jump)
except KeyError:
return
infile.close()
a.beginExecution()

A bunch of instructions which need to be written to some file:

0, >, 2
1, <, 0
2, >, 3
3, >, 4
4, >, 5
5, mark, 6
6, >, 7
7, exit

The output:

pal-178-222:~ shriphani$ python post.py
Initial Stage
.....[0], 0, 0, 0, 0, .....
File: input_file
.....0, [0], 0, 0, 0, .....
.....0, 0, [0], 0, 0, .....
.....0, 0, 0, [0], 0, .....
.....0, 0, 0, 0, [0], .....
.....0, 0, 0, 0, [1], .....
.....0, 0, 0, 0, 1, [0], .....
pal-178-222:~ shriphani$ python post.py

The full script can be obtained at http://shriphani.com/scripts/post.py

Well, later.

RPN Calculator – Keeping Boredom Away

Shriphani — Wed, 14 Jan 2009 20:09:35 +0000

Alright, those who know me well are bound to ask, 19 credit hours and you are bored? Answer: Yes. It is still the first week and we don’t seem to have gotten beyond the “introduce your loser self to the other non-interested members of the class” and since I have only 1 programming intensive course this semester, I should have lots of time to kill.

Well, my first script this semester is an RPN calculator. Totally useless for the vast majority of people out there but they know what to expect from someone who likes theoretical computer science.

So, I first began with a stack – in this case an array. I then keep populating it with numbers and every time the state of the stack changes, it prints out the current state.

If an operation is entered (only +, -, * and /), it performs the operation, replaces the appropriate positions in the stack and then prints out the current state.

Here is the code, Its been a while since I wrote any OOP stuff in Python and the “self” especially feels weird after an entire semester of Java…

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: shriphani@shriphani.com
#RPN Calculator

class Machine:
def __init__(self, stack=[]):
self.stack = []

def modifyStack(self, element):
”‘add to stack if input is float else run operation or complain’”

if self.isOperator(element):
self.operate(element)
self.printStack()
elif self.isFloat(element):
self.stack.append(element)
self.printStack()

else:
print "Only numbers and operators"

def isFloat(self, char):
”‘Checks whether the last item entered in the stack is a float or not’”
try:
float(char)
except ValueError:
return False
return True

def isOperator(self, char):
”‘Checks whether the last item entered in the stack is an operator or not’”
if char == ‘+’ or char == ‘-’ or char == ‘*’ or char == ‘/’:
return True
else:
return False

def operate(self, operator):
”‘Perform the stated operation on the last two elements in the stack’”

operand1 = float(self.stack[-1])
operand2 = float(self.stack[-2])

self.stack.pop(-1)
self.stack.pop(-1)

if operator==‘+’:
self.stack.append(operand1+operand2)

elif operator==‘-’:
self.stack.append(operand2-operand1)

elif operator==‘*’:
self.stack.append(operand1*operand2)

elif operator==‘/’:
self.stack.append(float(operand2)/float(operand1))

else:
print "God only knows what operation you have typed in"
self.stack += [operand2, operand1]
self.printStack()

def printStack(self):
print self.stack

def kickOff():
calc = Machine()
while True:
a = raw_input(‘Input: ‘)
if a != ”:
calc.modifyStack(a)
else:
calc.printStack()
raise SystemExit

print"Press Enter to Quit\n"
kickOff()

The calculator in action:

pal-179-083:~ shriphani$ python rpn.py
Press Enter to Quit

Input: 1
['1']
Input: 2
['1', '2']
Input: 3
['1', '2', '3']
Input: 4
['1', '2', '3', '4']
Input: 5
['1', '2', '3', '4', '5']
Input: +
['1', '2', '3', 9.0]
Input: h
Only numbers and operators
Input: -
['1', '2', -6.0]
Input:
['1', '2', -6.0]

In other news, I am really pissed with Picasa since I can’t see how many people have viewed my pics (http://picasaweb.google.com/shriphanip in case you are interested), I have begun filling my playlists with songs played at apple keynotes and in apple ads. Friends say this is an obsession with everything with the Apple stamp on it. I basically don’t care.

There has always been this one question bugging me since last semester. In Java:

class Test
{
public static void main(String[] args)
{
int a = 012345;
System.out.println(a);
}
}

When I run this:

pal-179-083:~ shriphani$ java Test
5349
pal-179-083:~ shriphani$

What is happening here?

Anyway, looking forward to this semester. Hope my GPA stays at 4.0

Boyer – Moore String Search (Good Suffix Shift)

Shriphani — Sun, 07 Dec 2008 22:09:27 +0000

The next string search algorithm I am going to cover seems pretty cool since the match is made in a reverse fashion. We check if the last character in the keyword equals some character in the text and decrease from that point on.As a result, a mismatch is detected extremely fast and this is also the reason why this algorithm is performs beautifully when the keyword is longer.

Now, when a mismatch occurs, the position where we look for the next character is determined by a table of values mapping each character in the keyword to an integer. Example, we find an “a” in the text which at a particular state is sitting atop an M in the keyword, we shift the position in the text by the corresponding number in our table and look again.

Here is how we generate the table:

bcs = {} #the table

def goodSuffixShift(key):

for i in xrange(len(key)-1, -1, -1):
if key[i] not in bcs.keys():
bcs[key[i]] = len(key)-i-1

Next, comes the actual search:

def search(text, key):

i = len(key)-1

index = len(key) -1

j = i

while True:

print str(i) + ", " + str(j)

if i == 0:
return j #if every character in the keyword matches, return current position in text

elif j > len(text):
return "not found" #if we run out of the string while searching, there is no chance…

elif text[j] != key[i] and text[j] not in bcs.keys():
j += len(key) #If there isn’t a match and we don’t have a switch value in our table, don’t bother looking for characters in the middle and start matching again
i = index

elif text[j] != key[i] and text[j] in bcs.keys():
j += bcs[text[j]] #move forward as table says and start looking again
i = index

else:
j -= 1 #in case a match is found, check for the character to the left
i -= 1

Here are some sample runs:

key_list = ["POWER", "HOUSE", "COMP", "SCIENCE", "SHRIPHANI", "BRUAH"]

text = "SHRIPHANI IS A COMPUTER SCIENCE POWERHOUSE"

for key in key_list:
goodSuffixShift(key)
print key + " location: " + str(search(text, key))
bcs = {}

The output:

tark-b-120:scripts shriphani$ python boyer_moore.py
POWER location: 32
HOUSE location: 37
COMP location: 15
SCIENCE location: 24
SHRIPHANI location: 0
BRUAH location: not found

You can get the entire script at http://shriphani.com/scripts/boyer_moore.py.

Got to get back to Psychology and GUI stuff in Java. Anyway, GUIs are for losers, CLI FTW !!!