Python LogisticRegressionCV.score方法代码示例

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
def classify(_char):
    print 'to fetch data'
    start_time = time.time()
    char_count = Character.objects.filter(char=_char, is_correct=1).count()
    if char_count < 10:
        return
    char_lst = Character.objects.filter(char=_char)
    y, X, ty, tX, t_charid_lst, test_accuracy_lst = prepare_data_with_database(char_lst)
    if len(y) == 0 or len(ty) == 0:
        return
    if 1 == len(set(y)) or len(y) < 10:
        return
    fetch_negative_samples(_char, X, y)
    if len(y) == 0 or len(ty) == 0:
        return
    if 1 == len(set(y)) or len(y) < 50:
        return

    print "fetch data done, spent %s seconds." % int(time.time() - start_time)
    start_time = time.time()
    print "traning: data size: %d" % len(y)
    model = LogisticRegressionCV(cv=5, solver='liblinear', n_jobs=1)
    try:
        model.fit(X, y)
        print "training done, spent %s seconds." % int(time.time() - start_time)
        #print 'params: '
        #for k, v in model.get_params().iteritems():
        #    print '\t', k, ' : ', v
        print 'score: ', model.score(X, y)
    except Exception, e:
        print 'except: ', e
        traceback.print_exc()
        return

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
def train(trainingData, pklFile):
	# ========================================================================= #
	# =============== STEP 1. DEFINE OUTPUT LEARNT MODEL FILE ================= #
	# ========================================================================= #
	if (pklFile == ''):
		os.system('rm -rf learntModel & mkdir learntModel')
		pklFile = 'learntModel/learntModel.pkl'
	
	# ========================================================================= #
	# ================= STEP 2. PREPARE AND FORMATTING DATA =================== #
	# ========================================================================= #
	NUMBER_OF_FEATURES = len(trainingData[0]) - 1
	NUMBER_OF_TRAINING_POINTS = len(trainingData)

	x = trainingData[:, range(0, NUMBER_OF_FEATURES)]
	y = trainingData[:, NUMBER_OF_FEATURES]
	
	# ========================================================================= #
	# ============== STEP 3. DECLARE PRIMITIVES BEFORE THE PARTY ============== #
	# ========================================================================= #
	minSquareError = np.inf
	targetAlpha = None
	alphas = np.logspace(-10, -2, 500)			
	
	# ========================================================================= #
	# ===== STEP 4. PERFORM FITTING WITH THE BEST ALPHA AND SAVE THE MODEL ==== #
	# ========================================================================= #
	clf = LogisticRegressionCV(Cs=alphas)
	clf.fit(x, y)
	joblib.dump(clf, pklFile)
	
	return {"intercept": clf.intercept_, "coef":clf.coef_, "alpha":clf.C_, "accuracy":clf.score(x,y)}

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
 def classify(self, mp, x_train, y_train, x_test):
     x_train = sm.add_constant(x_train)
     x_test = sm.add_constant(x_test)
     clf = LogisticRegressionCV(verbose=1, cv=5)
     log_to_info('Fitting a Logistic Regression to labeled training data...')
     clf = clf.fit(x_train, y_train)
     log_to_info('Training details')
     log_to_info('Classifier parameters: {}'.format(clf.get_params()))
     log_to_info('On training: {}'.format(clf.score(x_train, y_train) * 100.0))
     log_to_info('Predicting test value')
     y_test = clf.predict(x_test)
     log_to_info('Done!')
     return y_test

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
def classify_with_random_samples(char, positive_sample_count, auto_apply=False, random_sample=0):
    print char, positive_sample_count
    started = timezone.now()
    start_time = time.time()
    query = Character.objects.filter(char=char)
    positive_samples, negative_samples, test_X, test_y, test_char_id_lst, test_accuracy_lst = \
        prepare_data_with_database2(query)
    X = []
    y = []
    if random_sample != 0:
        if positive_sample_count > 0:
            if len(positive_samples) > positive_sample_count:
                positive_samples = random.sample(positive_samples, positive_sample_count)
            if len(negative_samples) > positive_sample_count:
                negative_samples = random.sample(negative_samples, positive_sample_count)
    else:
        if len(positive_samples) > positive_sample_count:
            positive_samples.sort(key=itemgetter(2), reverse=True)
            positive_samples = positive_samples[:positive_sample_count]
        if len(negative_samples) > positive_sample_count:
            negative_samples.sort(key=itemgetter(2))
            negative_samples = negative_samples[:positive_sample_count]
    for sample in positive_samples:
        X.append(sample[0])
        y.append(sample[1])
    for sample in negative_samples:
        X.append(sample[0])
        y.append(sample[1])
    train_count = len(y)
    predict_count = len(test_y)
    if 1 == len(set(y)) or train_count < 10 or predict_count == 0:
        return
    fetch_spent = int(time.time() - start_time)
    print "fetch data done, spent %s seconds." % fetch_spent
    start_time = time.time()
    print "traning: data size: %d" % len(y)
    model = LogisticRegressionCV(cv=5, solver='liblinear', n_jobs=1)
    try:
        model.fit(X, y)
        training_spent = int(time.time() - start_time)
        print "training done, spent %s seconds." % training_spent
        # print 'params: '
        # for k, v in model.get_params().iteritems():
        #    print '\t', k, ' : ', v
        print 'score: ', model.score(X, y)
    except Exception, e:
        print 'except: ', e
        traceback.print_exc()
        return

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
# modeling with categorical
dummies = pd.get_dummies(data['alchemy_category'])
second_model = pd.concat([X, dummies], axis = 1)

X2_train, X2_test, y2_train, y2_test = train_test_split(second_model, y)
lr2 = LogisticRegression()
lr2.fit(X2_train, y2_train)
lr2.predict(X2_test)
lr2.score(X2_test, y2_test)

# modeling with cross_validation
lrCV = LogisticRegressionCV()
lrCV.fit(X2_train, y2_train)
lrCV.predict(X2_test)
lrCV.score(X2_test, y2_test)

# models with pre normalized values & inclusion of ALL categorical variables
dummies2 = pd.get_dummies(data[maskCat])
data2 = pd.concat([X, dummies2], axis = 1)
data2 = normalize(data2, norm = 'l2')

X3_train, X3_test, y3_train, y3_test = train_test_split(data2, y)
lr3 = LogisticRegression()
lr3.fit(X3_train, y3_train)
lr3.predict(X3_test)
lr3.score(X3_test, y3_test)

lrCV2 = LogisticRegressionCV()
lrCV2.fit(X3_train, y3_train)

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
hh = np.array(np.asarray(test).reshape(-1))
print hh.dtype 
hhh = np.logical_not( np.isfinite(np.asarray(test).reshape(-1)) )
print hh[hhh]
"""
enc = OneHotEncoder(categorical_features=[4])
enc.fit(train)
train = enc.transform(train)
test = enc.transform(test)

solver = LogRegCV(n_jobs=-1)
solver.fit(train, data_train.Survived)
res = solver.predict(test)
res = pd.DataFrame({"PassengerId": data_test.PassengerId, "Survived": res})
res.to_csv("../output/logic_0.csv", index=False)
print solver.score(train, data_train.Survived)

solver = LogRegCV(n_jobs=-1, scoring='roc_auc')
solver.fit(train, data_train.Survived)
res = solver.predict(test)
res = pd.DataFrame({"PassengerId": data_test.PassengerId, "Survived": res})
res.to_csv("../output/logic_1.csv", index=False)
print solver.score(train, data_train.Survived)


solver = LogRegCV(n_jobs=-1, scoring='average_precision')
solver.fit(train, data_train.Survived)
res = solver.predict(test)

res = pd.DataFrame({"PassengerId": data_test.PassengerId, "Survived": res})
res.to_csv("../output/logic_2.csv", index=False)

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
X = x[1:, :]
y = y[1:]
X = X.astype(np.float)
y = y.astype(np.float)

##################### Logistic Reg CV ############

# For the grid of Cs values (that are set by default to be ten values in a logarithmic scale between 1e-4 and 1e4)
# If Cs is as an int, then a grid of Cs values are chosen in a logarithmic scale between 1e-4 and 1e4.
# Like in support vector machines, smaller values specify stronger regularization.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

lr_cv = LogisticRegressionCV(Cs = 10, cv=5)
lr_cv = lr_cv.fit(X_train, y_train)
print 'Logistic Regression train accuracy', lr_cv.score(X_train, y_train)
print 'Logistic Regression CV test accuracy', lr_cv.score(X_test, y_test)

######### Logistic Regression Grid Search for C ############

print '******** Logistic Reg *********'

tuned_parameters = {'C': np.linspace(0.1, 10, 10)}

scores = ['precision', 'recall']

for score in scores:
    print("# Tuning hyper-parameters for %s" % score)
    clf = GridSearchCV(LogisticRegression(), tuned_parameters, cv=4, scoring='%s_weighted' % score)
    clf.fit(X_train, y_train)
    print("Best parameters set found on development set:")

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
# Prepare data
iris = sns.load_dataset("iris")
X = iris.values[:, 0:4]
y = iris.values[:, 4]

# Make test and train set
train_X, test_X, train_y, test_y = train_test_split(X, y, train_size=0.5, random_state=0)

################################
# Evaluate Logistic Regression
################################
lr = LogisticRegressionCV()
lr.fit(train_X, train_y)
pred_y = lr.predict(test_X)
print("Test fraction correct (LR-Accuracy) = {:.2f}".format(lr.score(test_X, test_y)))


################################
# Evaluate Keras Neural Network
################################

# Make ONE-HOT
def one_hot_encode_object_array(arr):
        '''One hot encode a numpy array of objects (e.g. strings)'''
        uniques, ids = np.unique(arr, return_inverse=True)
        return np_utils.to_categorical(ids, len(uniques))


train_y_ohe = one_hot_encode_object_array(train_y)
test_y_ohe = one_hot_encode_object_array(test_y)

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
feature_names = ["Pclass","Age","SibSp","Parch","Fare","IsMale",
                 'EmbarkC','EmbarkQ', 'EmbarkS',
                 "Ticket-4digit","Ticket-5digit","Ticket-6digit","Ticket-7digit","Ticket-A","Ticket-C","Ticket-F","Ticket-Others","Ticket-P","Ticket-S","Ticket-W"]
Xtrain = train_df[feature_names]
ytrain = train_df["Survived"]

# --------------------------- scale train data
scaler = StandardScaler()
Xtrain_scaled = scaler.fit_transform(Xtrain)

# --------------------------- LR
lrcv = LogisticRegressionCV(Cs=30,cv=10)
lrcv.fit(Xtrain_scaled,ytrain)

lrcv.C_
lrcv.score(Xtrain_scaled,ytrain)

def pretty_print_coef(coefs, names=None, sort=False):
    if names == None:
        names = ["X%s" % x for x in range(len(coefs))]
    lst = zip(coefs, names)
    if sort:
        lst = sorted(lst,  key = lambda x:-np.abs(x[0]))
    return " + ".join("%s * %s" % (round(coef, 3), name)     for coef, name in lst)
pretty_print_coef(lrcv.coef_.ravel(),feature_names,True)

coefs = pd.DataFrame({"names":feature_names,"coefs":lrcv.coef_.ravel()},columns=["names","coefs"])
coefs["rank"] = np.abs(coefs.coefs)
coefs.sort_index(by="rank",inplace=True,ascending=False)
del coefs["rank"]

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
# ***************************** generate predictions on validation sets
def predict_features(base_estimators, X, scaledX):
    basepredicts = [
        estimator.estimator.predict(scaledX) if estimator.need_scale else estimator.estimator.predict(X)
        for estimator in base_estimators
    ]
    return pd.DataFrame(
        np.asarray(basepredicts).T, index=X.index, columns=[estimator.name for estimator in base_estimators]
    )


# ***************************** fit advanced features to validation target
validate_basepredicts = predict_features(base_estimators, Xvalidate, Xvalidate_scaled)
lrcv = LogisticRegressionCV(Cs=30, cv=10)
lrcv.fit(validate_basepredicts, yvalidate)
lrcv.score(validate_basepredicts, yvalidate)
common.make_coefs_frame(validate_basepredicts.columns, lrcv.coef_.ravel())

# fit again with whole data
basepredict_lr = LogisticRegression(C=lrcv.C_[0])
basepredict_lr.fit(validate_basepredicts, yvalidate)
basepredict_lr.score(validate_basepredicts, yvalidate)
common.make_coefs_frame(validate_basepredicts.columns, basepredict_lr.coef_.ravel())

# ***************************** test
test_df = pd.read_csv("test_processed.csv", index_col="PassengerId")
Xtest = test_df[feature_names]
Xtest_scaled = scaler.transform(Xtest)

test_basepredict = predict_features(base_estimators, Xtest, Xtest_scaled)
final_predictions = basepredict_lr.predict(test_basepredict)

# 需要导入模块: from sklearn.linear_model import LogisticRegressionCV [as 别名]
# 或者: from sklearn.linear_model.LogisticRegressionCV import score [as 别名]
x['SexCallClass']=x['SexN']*x['Call']*x['Pclass']

##x['AgeClass']=x['Age']*x['Pclass']
x['Family']=x['Parch']+x['SibSp']
##x['SexAge']=x['SexN']*x['Age']
x = (x-sp.mean(x))/sp.std(x)


n_train = 500
x_train = x.iloc[:n_train,:]
y_train = y.iloc[:n_train]
x_test = x.iloc[n_train:,:]
y_test = y.iloc[n_train:]

##x_test = x_test[~pd.isnull(x_test.Age)]
##y_test = y_test[~pd.isnull(x_test.Age)]

cv = KFold(n=len(x), n_folds=10)
clf = LogisticRegressionCV()
scores = []
aucs=[]
for train, test in cv:
    x_train, y_train = x.iloc[train,:], y.iloc[train]
    x_test, y_test = x.iloc[test,:], y.iloc[test]
    clf.fit(x_train, y_train)
    pr = clf.predict_proba(x_test)[:,1]
    scores.append(clf.score(x_test, y_test))
    precision, recall, thres = precision_recall_curve(y_test, clf.predict(x_test))
    aucs.append(auc(recall, precision))
print("Score = %s, Auc = %s"%(sp.mean(scores), sp.mean(aucs)))