Frequency percentage calculation

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
#reading the data

test_data = pd.read_csv('testdata.csv')

sorted_data=test_data.sort_values(by='Data',ascending=True)

actual_frequencey_percentage=[]
prev= 0
totaldata= sorted_data.count()

cd=1/totaldata
print cd
for row in sorted_data.iterrows():
    print row[1][0]
    new = cd + prev
    prev = new
    actual_frequencey_percentage.append(new)
   
print(actual_frequencey_percentage)

plt.plot(sorted_data, actual_frequencey_percentage)
plt.show()

alpha evaluation for multilabel

from __future__ import division
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#reading the data



def alpha_evaluation(predicted_df,test_df,alpha=0,beta=1,gamma=1):
    y_pred=predicted_df
    y_test = test_df
    y_pred[y_pred>=0.5] = 1
    y_pred[y_pred<0.5] = 0

    Mx=0  # number of misclassified
    Fx=0  # number of false predicted 

#print type(y_pred)
#print len(y_pred.index)
#print y_pred
#print y_test
#alpha=0
#beta=1
#gamma =1
    pred_class = [0] * len(y_pred.columns)
    test_class = [0] * len(y_test.columns)
    pscore_class = [0] * len(y_test.columns)
    rscore_class = [0] * len(y_test.columns)
    score_row = [0] * len(y_pred.index)

    #print ("pred_class is ", pred_class)
    for i in range(0, len(y_pred.index)):
        Mx=0
        Fx=0
        Sx =0
        Cx=0
        score =0
        selected_class=0
    # print("Row is ",i)
        for j in range(0, len(y_pred.columns)):
            #print ("Column is ",j)
            if y_pred.values[i,j] == 1:
                pred_class[j] +=1
                selected_class = j
            if y_test.values[i,j] == 1:
                test_class[j] +=1
                    #print (y_pred.values[i,j], y_test.values[i,j])
            if y_pred.values[i,j] == 0 and y_test.values[i,j] == 1:
                Mx += 1
                #print ("mx")
            elif  y_pred.values[i,j] == 1 and y_test.values[i,j] == 0:
                Fx += 1
                #print ("fx")
            elif y_pred.values[i,j] == 1 and y_test.values[i,j] == 1:
                Sx +=1
                #print ("Sx")
            if y_pred.values[i,j] == 1 or y_test.values[i,j] == 1:
                Cx +=1
                #print ("Cx")
        print (Mx, Fx,Sx,Cx)
       
        if Sx == 0:
            score =0
        else:
            temp = 1 - (((beta * Mx) + (gamma *Fx))/Cx)
            #print("fx is ",Fx)
            #print("gama into fx  and divided by 2 is ",(gamma * Fx)/2)
            #print ("temp is ",temp)
            score = pow(temp,alpha)
        #print ("score is ",score)
       
        score_row[i] +=score
    for i in range(0, len(y_pred.index)):
        for j in range(0, len(y_pred.columns)):
            if y_pred.values[i,j] == 1:
                pscore_class[j] += score_row[i]
            if y_test.values[i,j] == 1:
                rscore_class[j] += score_row[i]
    #print ("pscore_class is ", pscore_class)
    #print ("rscore_class is ", rscore_class)
    #print ("pred_class is ", pred_class) 
    #print ("test_class is ", test_class)
   
    print(" class,  precision, recall")
    for j in range(0, len(y_pred.columns)):
        print(j, pscore_class[j]/pred_class[j], rscore_class[j]/test_class[j])
    del y_pred
    del y_test
   

y_pred1 = pd.read_csv('y_pred1.csv',header=None)
y_test1 = pd.read_csv('y_test.csv',header=None)

alpha_evaluation(y_pred1,y_test1,alpha=1,beta = 1/4)

distance between vectors

v2 = np.loadtxt("myvector2.txt")
def euclidean_dist(vec1,vec2):
    return np.sqrt(np.sum((vec1-vec2)**2))

def find_closest(word_index, vectors):
    min_dist = 100000
    min_index = -1
    query_vector = vectors[word_index]
    for index, vector in enumerate(vectors):
        if euclidean_dist(vector, query_vector)< min_dist and not np.array_equal(vector, query_vector):
            min_dist = euclidean_dist(vector, query_vector)
            min_index = index
    return min_index

print(int2diag[find_closest(diag2int['I63.4'],v2)])
print(int2diag[find_closest(diag2int['F71.1'],v2)])
print(int2diag[find_closest(diag2int['R00.2'],v2)])

euclidean_dist(v2[diag2int['I63.4']],v2[diag2int['S82.9']])

PHP passing $_GET in linux command prompt

php -r '$_GET["key"]="value"; require_once("script.php"); 

language generation in keras

https://machinelearningmastery.com/how-to-develop-a-word-level-neural-language-model-in-keras/

Language to language translation

https://medium.com/@ageitgey/machine-learning-is-fun-part-5-language-translation-with-deep-learning-and-the-magic-of-sequences-2ace0acca0aa

Word2vec visualization

link
https://labsblog.f-secure.com/2018/01/30/nlp-analysis-of-tweets-using-word2vec-and-t-sne/

Better one for skip-gram
http://mccormickml.com/2016/04/19/word2vec-tutorial-the-skip-gram-model/