示例#1
0
    def test_pairwise_transform(self):
        X = np.array([[0.2, 0.3, 0.4], [0.1, 0.7, 0.4], [0.3, 0.4, 0.1],
                      [0.8, 0.4, 0.3], [0.9, 0.35, 0.25]])
        y = np.array([0, 1, 0, 0, 2])
        qid = np.array([1, 1, 1, 2, 2])

        ranker = LambdaRankNN(input_size=X.shape[1],
                              hidden_layer_sizes=(
                                  16,
                                  8,
                              ),
                              activation=(
                                  'relu',
                                  'relu',
                              ),
                              solver='adam')
        X1, X2, Y, weight = ranker._transform_pairwise(X, y, qid)

        self.assertTrue((X1 == np.array([[0.1, 0.7, 0.4], [0.1, 0.7, 0.4],
                                         [0.8, 0.4, 0.3]])).all())
        self.assertTrue((X2 == np.array([[0.2, 0.3, 0.4], [0.3, 0.4, 0.1],
                                         [0.9, 0.35, 0.25]])).all())
        self.assertTrue((Y == np.array([1, 1, 0])).all())
        self.assertTrue((weight == np.array(
            [0.36907024642854247, 0.13092975357145753,
             0.36907024642854247])).all())
示例#2
0
def lambdarank(entity_info,flag):
    if entity_info:
        if flag == 0:
            X = []
            print(entity_info)
            for i in entity_info:
                X.append(i[2:])
            X = np.array(X)
            print(X)
            ranker = LambdaRankNN(input_size=X.shape[1], hidden_layer_sizes=(16,8,), activation=('relu', 'relu',), solver='adam')
            ranker.model.load_weights('LambdaRankNNmaster/Examples/ccks20_entity.h5')
            y_pred = ranker.predict(X)
            K.clear_session()
            return y_pred
        else:
            X = []
            print(entity_info)
            for i in entity_info:
                X.append(i[5:])
            X = np.array(X)
            print(X)
            ranker = LambdaRankNN(input_size=X.shape[1], hidden_layer_sizes=(16,8,), activation=('relu', 'relu',), solver='adam')
            ranker.model.load_weights('LambdaRankNNmaster/Examples/ccks20_relation.h5')
            y_pred = ranker.predict(X)
            K.clear_session()
            return y_pred
    else:
        return entity_info
示例#3
0
def lambdarank(entity_info,flag):
    if flag == 0:
        X = []
        print(entity_info)
        for i in entity_info:
            X.append(i[2:])
        X = np.array(X)
        print(X)
        ranker = LambdaRankNN(input_size=X.shape[1], hidden_layer_sizes=(16,8,), activation=('relu', 'relu',), solver='adam')
        ranker.model.load_weights('LambdaRankNNmaster\Examples\entity_select225.h5')
        y_pred = ranker.predict(X)
        return y_pred
    else:
        X = []
        print(entity_info)
        for i in entity_info:
            X.append(i[4:])
        X = np.array(X)
        print(X)
        ranker = LambdaRankNN(input_size=X.shape[1], hidden_layer_sizes=(16,8,), activation=('relu', 'relu',), solver='adam')
        ranker.model.load_weights('LambdaRankNNmaster\Examples\drelation_select22515.h5')
        y_pred = ranker.predict(X)
        return y_pred
示例#4
0
import numpy as np
from LambdaRankNN import LambdaRankNN, RankNetNN
import h5py
import keras
# generate query data
X = np.array([[0.2, 0.3, 0.4], [0.1, 0.7, 0.4], [0.3, 0.4, 0.1],
              [0.8, 0.4, 0.3], [0.9, 0.35, 0.25]])
y = np.array([3, 1, 2, 1, 2])
qid = np.array([1, 1, 1, 2, 2])

ranker = LambdaRankNN(input_size=X.shape[1],
                      hidden_layer_sizes=(
                          16,
                          8,
                      ),
                      activation=(
                          'relu',
                          'relu',
                      ),
                      solver='adam')
ranker.fit(X, y, qid, epochs=5)
#ranker.model.save_weights('ranker_weights.h5')
y_pred = ranker.predict(X)
print(y_pred)
ranker.evaluate(X, y, qid, eval_at=2)
示例#5
0
                                                                             30000]
test_X, test_y, test_queries = test_X[:
                                      30000, :], test_y[:
                                                        30000], test_queries[:
                                                                             30000]

print("Train Shape", train_X.shape, train_y.shape)
print("Valid Shape", vali_X.shape, vali_y.shape)
print("Test Shape", test_X.shape, test_y.shape)

# Train LambdaRankNN model
ranker = LambdaRankNN(input_size=train_X.shape[1],
                      hidden_layer_sizes=(
                          8,
                          4,
                      ),
                      activation=(
                          'relu',
                          'relu',
                      ),
                      solver='adam')
ranker.fit(train_X, train_y, train_queries, epochs=10)

train_y_pred = ranker.predict(train_X)
vali_y_pred = ranker.predict(vali_X)
test_y_pred = ranker.predict(test_X)
ranker.evaluate(test_X, test_y, test_queries, eval_at=2)

df1 = pd.DataFrame(train_y_pred)
df2 = pd.DataFrame(vali_y_pred)
df3 = pd.DataFrame(test_y_pred)
示例#6
0
Created on Sun Apr 19 00:04:15 2020

@author: Rishab
"""

from LambdaRankNN import LambdaRankNN
from DataLoader import read_dataset

X, y, queries = read_dataset('./data_output/train.tsv')
VX, Vy, Vqueries = read_dataset('./data_output/test.tsv')

y = y.astype(int)
qids = queries.astype(int)
ranker = LambdaRankNN(input_size=X.shape[1],
                      hidden_layer_sizes=(
                          16,
                          8,
                      ),
                      activation=(
                          'relu',
                          'relu',
                      ),
                      solver='adam')
ranker.fit(X, y, qids, epochs=20)
# y_pred = ranker.predict(TX)

Vy = Vy.astype(int)
Vqids = Vqueries.astype(int)

ranker.evaluate(VX, Vy, Vqids, eval_at=2)