Python LabelEncoder.inverse_transform方法代码示例

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
class PipelineNet(NeuralNet): # By default Lasagne is super finicky with inputs and outputs. So I just handle most of the pre and postprocessing for you.
    def fit(self,X, y,**params):
        self.label_encoder = LabelEncoder()
        self.one_hot = OneHotEncoder()

        y = list(map(lambda x:[x],self.label_encoder.fit_transform(y)))
        y = np.array(self.one_hot.fit_transform(y).toarray(),dtype=np.float32)
        X = np.array(X,dtype=np.float32)

        self.output_num_units=len(y[0])
        self.input_shape=(None,X.shape[1])

        self.output_nonlinearity=lasagne.nonlinearities.softmax

        return NeuralNet.fit(self,X,y,**params)

    def predict(self, X):
        X = np.array(X,dtype=np.float32)
        preds = NeuralNet.predict(self,X)

        preds = np.argmax(preds,axis=1)
        preds = self.label_encoder.inverse_transform(preds)

        return preds

    def score(self, X, y):
        return sklearn.metrics.accuracy_score(self.predict(X),y)

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def one_partition_NDCG(x ,labels ,model ,i ,factor):
    le = LabelEncoder()
    y = le.fit_transform(labels)   
    piv_train = x.shape[0]
    trans_x = []
    trans_y = []
    test_x = []
    test_y = []
    if i == 0:
        trans_x = x[(i+1)*factor:] 
        trans_y = y[(i+1)*factor:] 
        test_x = x[:(i+1)*factor]
        test_y = y[:(i+1)*factor]
    elif i+1 == piv_train/factor:
        trans_x = x[:i*factor] 
        trans_y = y[:i*factor] 
        test_x = x[i*factor:]
        test_y = y[i*factor:]
    else:
        trans_x = np.concatenate((x[:i*factor],x[(i+1)*factor:]))
        trans_y = np.concatenate((y[:i*factor],y[(i+1)*factor:]))
        test_x = x[i*factor:(i+1)*factor]
        test_y = y[i*factor:(i+1)*factor]
    model.fit(trans_x,trans_y)
    y_pred = model.predict_proba(test_x)
    ids = []  
    cts = []  
    for j in range(factor):
        cts += [le.inverse_transform(np.argsort(y_pred[j])[::-1])[:5].tolist()]
    preds = pd.DataFrame(cts)
    truth = pd.Series(labels[i*factor:(i+1)*factor])
    #truth = pd.Series(le.inverse_transform(test_y).tolist())
    return mean_NDCG(preds, truth)

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
class Classifier(BaseEstimator):
    def __init__(self):
        self.label_encoder = LabelEncoder()
        self.scaler = StandardScaler()
        self.clf = None
        self.param = {'eval_metric':'mlogloss'}
        self.param['num_class'] = 9
        self.param['subsample'] = 0.795
        self.param['gamma'] = 0.9        
        self.num_round = 170
        self.obj = 'multi:softprob'
 
    def fit(self, X, y):        
        X = self.scaler.fit_transform(X.astype(np.float32))              
        y = self.label_encoder.fit_transform(y).astype(np.int32)
        dtrain = xgb.DMatrix( X, label=y.astype(np.float32))
        
        self.param['objective'] = self.obj  
        self.clf = xgb.train(self.param, dtrain, self.num_round)  
 
    def predict(self, X):
        X = self.scaler.transform(X.astype(np.float32))
        dtest = xgb.DMatrix(X)       
        label_index_array = np.argmax(self.clf.predict(dtest), axis=1)
        return self.label_encoder.inverse_transform(label_index_array)
 
    def predict_proba(self, X):
        X = self.scaler.transform(X.astype(np.float32))
        dtest = xgb.DMatrix(X)
        return self.clf.predict(dtest)

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
    def test_same_inverse_transform(self):
        Y, Y_rdd = self.make_dense_randint_rdd(low=0, high=10, shape=(1000,))

        local = LabelEncoder().fit(Y)
        dist = SparkLabelEncoder().fit(Y_rdd)

        assert_array_equal(local.inverse_transform(Y), dist.inverse_transform(Y_rdd).toarray())

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def process_one_cell(df_train, df_test, grid_id, th):
    """
    Classification inside one grid cell.
    """
    # Working on df_train
    df_cell_train = df_train.loc[df_train.grid_cell == grid_id]
    place_counts = df_cell_train.place_id.value_counts()
    mask = (place_counts[df_cell_train.place_id.values] >= th).values
    df_cell_train = df_cell_train.loc[mask]

    # Working on df_test
    df_cell_test = df_test.loc[df_test.grid_cell == grid_id]
    row_ids = df_cell_test.index

    # Preparing data
    le = LabelEncoder()
    y = le.fit_transform(df_cell_train.place_id.values)
    X = df_cell_train.drop(['place_id', 'grid_cell'], axis=1).values.astype(int)
    X_test = df_cell_test.drop(['grid_cell'], axis=1).values.astype(int)

    # Applying the classifier
    clf = KNeighborsClassifier(n_neighbors=conf['neighbours'], weights='distance',
                               metric='manhattan')
    clf.fit(X, y)
    y_pred = clf.predict_proba(X_test)
    pred_labels = le.inverse_transform(np.argsort(y_pred, axis=1)[:, ::-1][:, :3])
    return pred_labels, row_ids

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def process_one_cell(df_cell_train, df_cell_test):
    
    #Working on df_train
    place_counts = df_cell_train.place_id.value_counts()
    mask = (place_counts[df_cell_train.place_id.values] >= 5).values
    df_cell_train = df_cell_train.loc[mask]
    
    #Working on df_test
    row_ids = df_cell_test.index
    
    #Feature engineering on x and y
    df_cell_train.loc[:,'x'] *= 462.0
    df_cell_train.loc[:,'y'] *= 975.0
    df_cell_test.loc[:,'x'] *= 462.0
    df_cell_test.loc[:,'y'] *= 975.0

    #Preparing data
    le = LabelEncoder()
    y = le.fit_transform(df_cell_train.place_id.values)
    X = df_cell_train.drop(['place_id'], axis=1).values
    
    #Applying the classifier, ct = 5.3 #5.1282
    clf = KNeighborsClassifier(n_neighbors=np.floor(np.sqrt(y.size)/5.2).astype(int), 
                            weights=calculate_distance,metric='manhattan',n_jobs=2)
    clf.fit(X, y)
    y_pred = clf.predict_proba(df_cell_test.values)
    ##1
    #pred_labels = le.inverse_transform(np.argsort(y_pred, axis=1)[:,::-1][:,:3]) 
    pred_labels = le.inverse_transform(np.argsort(y_pred, axis=1)[:,::-1][:,:n_topx]) 
    
    return pred_labels, row_ids

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
    def process_cell(self, df_cell_train, df_cell_test, window):

        place_counts = df_cell_train.place_id.value_counts()
        mask = (place_counts[df_cell_train.place_id.values] >= th).values
        df_cell_train = df_cell_train.loc[mask]

        # Working on df_test
        row_ids = df_cell_test.index

        # Preparing data
        le = LabelEncoder()
        y = le.fit_transform(df_cell_train.place_id.values)
        X = df_cell_train.drop(['place_id', ], axis=1).values.astype(int)
        X_test = df_cell_test.values.astype(int)

        # Applying the classifier
        clf1 = KNeighborsClassifier(n_neighbors=50, weights='distance',
                                    metric='manhattan')
        clf2 = RandomForestClassifier(n_estimators=50, n_jobs=-1)
        eclf = VotingClassifier(estimators=[('knn', clf1), ('rf', clf2)], voting='soft')

        eclf.fit(X, y)
        y_pred = eclf.predict_proba(X_test)
        pred_labels = le.inverse_transform(np.argsort(y_pred, axis=1)[:, ::-1][:, :3])
        return pred_labels, row_ids

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def test_vote_soft():
    X,y,test_X,test_Y =get_test_data()

    print("bag of words")
    bow = BagOfWordsClassifier()
    bow_probs = bow.get_proba(X,y,test_X,prefix="t")

    print("direct attribute")
    da = DirectAttributeClassifier()
    da_probs = da.get_proba(X,y,test_X,prefix="t")

    probs = zip(*[item for p in [bow_probs,da_probs] for item in p])
    train_probs = probs[0]
    test_probs = probs[1]
    print(len(train_probs))
    for prob in train_probs:
        print(prob.shape)
        print(type(prob))
    #train_attr = reduce(lambda a,b:a+b,train_probs)
    test_attr = reduce(lambda a,b:a+b,test_probs)

    pred = test_attr.idxmax(1)
    from sklearn.preprocessing import LabelEncoder
    le = LabelEncoder()
    le.fit(y)
    pred = le.inverse_transform(pred)

    print(metrics.accuracy_score(test_Y,pred))

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def process_1_grid(df_train, df_test, grid, threshold):

	# Creating data with the particular grid id.
	df_train_1_grid = df_train.loc[df_train.grid_num == grid]
	df_test_1_grid = df_test.loc[df_test.grid_num == grid]
	place_counts = df_train_1_grid.place_id.value_counts()
	mask = (place_counts[df_train_1_grid.place_id.values] >= threshold).values
	df_train_1_grid = df_train_1_grid.loc[mask]
	# Label Encoding
	le = LabelEncoder()
	labels = le.fit_transform(df_train_1_grid.place_id.values)
	
	# Computing train and test feature data for grid grid.
	X = df_train_1_grid.drop(['place_id','grid_num'], axis=1).values.astype(int)
	X_test = df_test_1_grid.drop(['grid_num'], axis=1).values.astype(int)
	row_id = df_test_1_grid.index
	
	# KNN Classifier 
	clf = KNeighborsClassifier(n_neighbors=20, weights= 'distance', metric='manhattan')
	#clf = GaussianNB()
	# Training of the classifier
	#clf = XGBClassifier(max_depth=10, learning_rate=0.5, n_estimators=25,objective='multi:softprob', subsample=0.5, colsample_bytree=0.5, seed=0)                  
	clf.fit(X,labels)

	
	# Predicting probabilities for each of the label for test data.
	prob_y = clf.predict_proba(X_test)
	
	# Transforming back to labels from One hot Encoding
	pred_labels = le.inverse_transform(np.argsort(prob_y, axis=1)[:,::-1][:,:3])
	return pred_labels, row_id

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
 class labelOnehotEnc():
     def __init__(self):
         self.le = LabelEncoder()
         self.oe = OneHotEncoder(sparse=False)   
     def label_fit(self,x):
         feature = self.le.fit_transform(x)
         self.oe = OneHotEncoder(sparse=False)
         return self.oe.fit_transform(feature.reshape(-1,1))
     def onehot_inverse(self,x):
         self.indecies = []
         for t in range(len(x)):
             ind = np.argmax((x[t]))
             self.indecies.append(ind)
         return self.le.inverse_transform(self.indecies)
     def inverse_label(self,x):
         return self.le.inverse_transform(x)

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def test_hard_vote():
    X,y,test_X,test_Y =get_test_data()

    print("bag of words")
    bow = BagOfWordsClassifier()
    bow_probs = bow.get_proba(X,y,test_X,prefix="t")

    print("direct attribute")
    da = DirectAttributeClassifier()
    da_probs = da.get_proba(X,y,test_X,prefix="t")

    probs = zip(*[item for p in [bow_probs,da_probs] for item in p])
    #train_probs = probs[0]
    test_probs = probs[1]
    print(len(test_probs))
    preds = [x.idxmax(1) for x in test_probs]
    pred = np.zeros(len(preds[0]),dtype=np.int8)
    print(len(pred))
    for i in range(len(preds[0])):
        votes = [p[i] for p in preds]
        print(votes)
        pred[i]= max(set(votes),key=votes.count)
        print(pred[i])
    from sklearn.preprocessing import LabelEncoder
    le = LabelEncoder()
    le.fit(y)
    pred = le.inverse_transform(pred)

    print(metrics.accuracy_score(test_Y,pred))

    """

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
class LogisticRegression:
    """
    Logistic regression.
    Minimize regularized log-loss:
        L(x, y|w) = - sum_i log p(y_i|x_i, w) + l2 ||w||^2
        p(y|x, w) = exp(w[y].x) / (sum_y' exp(w[y'].x))

    Parameters
    ----------
    l2: float, default=0
        L2 regularization strength
    """
    def __init__(self, l2=0):
        self.l2 = l2
        self.loss = LogisticLoss()

    def fit(self, X, y):
        self.label_encoder_ = LabelEncoder()
        y = self.label_encoder_.fit_transform(y).astype(numpy.int32)
        self.n_classes = len(numpy.unique(y))
        self.coef_ = numpy.zeros((X.shape[1] + 1) * (self.n_classes - 1), dtype=numpy.float64)
        dataset = IntegerDataset(X, y)
        self.loss.fit(dataset, self.coef_, self.l2)
        return self

    def predict(self, X):
        n_features = self.coef_.size/(self.n_classes - 1) - 1
        assert X.shape[1] == n_features
        return self.label_encoder_.inverse_transform(self.loss.predict(n_features, self.n_classes, self.coef_, X))

    def predict_proba(self, X):
        n_features = self.coef_.size/(self.n_classes - 1) - 1
        assert X.shape[1] == n_features
        return self.loss.predict_proba(n_features, self.n_classes, self.coef_, X)

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
class Classifier(BaseEstimator):
    def __init__(self):
        self.label_encoder = LabelEncoder()
        self.scaler = StandardScaler()
        self.clf = None        
 
    def fit(self, X, y):        
        X = self.scaler.fit_transform(X.astype(np.float32))              
        y = self.label_encoder.fit_transform(y).astype(np.int32)
        dtrain = xgb.DMatrix( X, label=y.astype(np.float32))
        
        param = {'objective':'multi:softprob', 'eval_metric':'mlogloss'}
        param['nthread'] = 4
        param['num_class'] = 9
        param['colsample_bytree'] = 0.55
        param['subsample'] = 0.85
        param['gamma'] = 0.95
        param['min_child_weight'] = 3.0
        param['eta'] = 0.05
        param['max_depth'] = 12
        num_round = 400 # to be faster ??  
        #num_round = 820
        
        self.clf = xgb.train(param, dtrain, num_round)  
 
    def predict(self, X):
        X = self.scaler.transform(X.astype(np.float32))
        dtest = xgb.DMatrix(X)       
        label_index_array = np.argmax(self.clf.predict(dtest), axis=1)
        return self.label_encoder.inverse_transform(label_index_array)
 
    def predict_proba(self, X):
        X = self.scaler.transform(X.astype(np.float32))
        dtest = xgb.DMatrix(X)
        return self.clf.predict(dtest)

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def process_one_cell_df(train_cell, test_cell, g):
    """
    Return:
    ------    
    pred_labels: numpy ndarray
                 Array with the prediction of the top 3 labels for each sample
    row_ids: IDs of the samples in the submission dataframe 
    """   

    train = np.frombuffer(shared_train).reshape(train_x, train_y)
    test = np.frombuffer(shared_test).reshape(test_x, test_y)

    if (train_cell[0] >= train_cell[1]) | (test_cell[0] >= test_cell[1]):
        return None, None
    row_ids = test[test_cell[0]:test_cell[1], 0].astype(int)

    le = LabelEncoder()
    y = le.fit_transform(train[train_cell[0]:train_cell[1], 0])
    X = train[train_cell[0]:train_cell[1], 1:]

    clf = create_classifier(g.clf, y.size)
    clf.fit(X, y)
    
    X_test = test[test_cell[0]:test_cell[1], 1:]
    y_prob = clf.predict_proba(X_test)

    pred_y = np.argsort(y_prob, axis=1)[:,::-1][:,:g.top]
    pred_labels = le.inverse_transform(pred_y).astype(np.int64)
    
    labs = pd.DataFrame(pred_labels, index=row_ids)
    labs.index.name = "row_id"
    probs = pd.DataFrame(y_prob[np.arange(len(y_prob)).reshape(-1,1), pred_y], index=row_ids)
    probs.index.name = "row_id"
    
    return labs, probs

# 需要导入模块: from sklearn.preprocessing import LabelEncoder [as 别名]
# 或者: from sklearn.preprocessing.LabelEncoder import inverse_transform [as 别名]
def process_one_cell(df_cell_train, df_cell_test):
    
    #Working on df_train
    place_counts = df_cell_train.place_id.value_counts()
    mask = (place_counts[df_cell_train.place_id.values] >= 8).values
    df_cell_train = df_cell_train.loc[mask]
    
    #Working on df_test
    row_ids = df_cell_test.index
    
    #Feature engineering on x and y
    df_cell_train.loc[:,'x'] *= 500.0
    df_cell_train.loc[:,'y'] *= 1000.0
    df_cell_test.loc[:,'x'] *= 500.0
    df_cell_test.loc[:,'y'] *= 1000.0
    
    #Preparing data
    le = LabelEncoder()
    y = le.fit_transform(df_cell_train.place_id.values)
    X = df_cell_train.drop(['place_id'], axis=1).values
    X_test = df_cell_test.values

    #Applying the classifier
    clf = KNeighborsClassifier(n_neighbors=36, weights=calculate_distance, 
                               metric='manhattan')
    clf.fit(X, y)
    y_pred = clf.predict_proba(X_test)
    pred_labels = le.inverse_transform(np.argsort(y_pred, axis=1)[:,::-1][:,:3]) 
    
    return pred_labels, row_ids