def do(train_data, train_label, test_data, test_label=None, adjust_parameters=True, k=5):
train_data = np.array(train_data).squeeze()
train_label = np.array(train_label).squeeze()
test_data = np.array(test_data).squeeze()
if test_label is not None:
test_label = np.array(test_label).squeeze()
if not adjust_parameters:
knn = KNeighborsClassifier(n_neighbors=k, n_jobs=8)
knn.fit(train_data, train_label)
predicted_label = knn.predict(test_data)
if test_label is not None:
acc = accuracy_score(test_label, predicted_label)
print 'acc is ', acc
return predicted_label
else:
max_acc = 0.0
max_k = 0
max_predicted = None
for k in range(1, 11):
knn = KNeighborsClassifier(n_neighbors=k, n_jobs=8)
knn.fit(train_data, train_label)
predicted_label = knn.predict(test_data)
acc = accuracy_score(test_label, predicted_label)
if acc > max_acc:
max_acc = acc
max_k = k
max_predicted = predicted_label
print 'k = ', k, ' acc is ', acc
print 'max acc is ', max_acc, ' responding to k is ', max_k
return max_predicted, max_k
def run_main():
file_df = pd.read_csv('../dataset/voice.csv')
# print file_df
insect_dataset(file_df)
#填充空数据
drop_na(file_df)
#查看label的个数 分组显示
# print file_df['label'].value_counts()
#特征分布可视化
fea_name1 = 'meanfun'
fea_name2 = 'centroid'
#两个属性的特征图
# visaulize_two_feature(file_df,fea_name1,fea_name2)
#艺术性属性的特征图
# visaulize_single_feature(file_df,fea_name1)
#多个特征
fea_name = ['meanfreq', 'Q25', 'Q75', 'skew', 'centroid', 'label']
# visaulize_muilt_feature(file_df,fea_name)
X = file_df.iloc[:, :-1].values
file_df['label'].replace('male', 0, inplace=True)
file_df['label'].replace('female', 1, inplace=True)
y = file_df['label'].values
#特征归一化
X = preprocessing.scale(X)
#分割训练集，测试集
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=1 / 3.,
random_state=5)
#选择模型 交叉验证
cv_scores = []
k_range = range(1, 31)
for k in k_range:
knn = KNeighborsClassifier(k)
# print 'knn:',knn
scores = cross_val_score(knn,
X_train,
y_train,
cv=10,
scoring='accuracy')
score_mean = scores.mean()
cv_scores.append(score_mean)
print '%i:%.4f' % (k, score_mean)
best_k = np.argmax(cv_scores) + 1
#训练模型
knn_model = KNeighborsClassifier(best_k)
knn_model.fit(X_train, y_train)
print '测试模型，准确率：', knn_model.score(X_test, y_test)
return ''
def __init__(self, estimator=KNeighborsClassifier(n_neighbors=10), dimensionality_reduction=PCA(n_components=2), acceptance_threshold=0.03, n_decision_boundary_keypoints=60, n_connecting_keypoints=None, n_interpolated_keypoints=None, n_generated_testpoints_per_keypoint=15, linear_iteration_budget=100, hypersphere_iteration_budget=300, verbose=True):
if acceptance_threshold == 0:
raise Warning(
"A nonzero acceptance threshold is strongly recommended so the optimizer can finish in finite time")
if linear_iteration_budget < 2 or hypersphere_iteration_budget < 2:
raise Exception("Invalid iteration budget")
self.classifier = estimator
self.dimensionality_reduction = dimensionality_reduction
self.acceptance_threshold = acceptance_threshold
if n_decision_boundary_keypoints and n_connecting_keypoints and n_interpolated_keypoints and n_connecting_keypoints + n_interpolated_keypoints != n_decision_boundary_keypoints:
raise Exception(
"n_connecting_keypoints and n_interpolated_keypoints must sum to n_decision_boundary_keypoints (set them to None to use calculated suggestions)")
self.n_connecting_keypoints = n_connecting_keypoints if n_connecting_keypoints != None else n_decision_boundary_keypoints / 3
self.n_interpolated_keypoints = n_interpolated_keypoints if n_interpolated_keypoints != None else n_decision_boundary_keypoints * 2 / 3
self.linear_iteration_budget = linear_iteration_budget
self.n_generated_testpoints_per_keypoint = n_generated_testpoints_per_keypoint
self.hypersphere_iteration_budget = hypersphere_iteration_budget
self.verbose = verbose
self.decision_boundary_points = []
self.decision_boundary_points_2d = []
self.X_testpoints = []
self.y_testpoints = []
self.background = []
self.steps = 3
self.hypersphere_max_retry_budget = 20
self.penalties_enabled = True
self.random_gap_selection = False
def KNN_method(X, y):
skf = StratifiedKFold(n_splits=4, random_state=42)
skf.get_n_splits(X, y)
for train_index, test_index in skf.split(X, y):
print("Train:", train_index, "Validation:", test_index)
trainX, testX = X[train_index], X[test_index]
trainY, testY = y[train_index], y[test_index]
#here starts KNN
#how many neighbours want to use in the KNC
kvalues = [1, 3, 5, 7, 9, 11, 13, 15, 19, 24, 30, 40, 50, 60, 70, 90]
dist = ['manhattan', 'euclidean', 'chebyshev']
results = {}
for element in dist:
accuracy_results = []
for k in kvalues:
knn = KNeighborsClassifier(n_neighbors=k, metric=element)
knn.fit(trainX, trainY)
predictedY = knn.predict(testX)
accuracy_results.append(accuracy_score(testY, predictedY))
results[element] = accuracy_results
print("Results of model preparation for: " + str(results))
plt.figure()
multiple_line_chart(plt.gca(),
kvalues,
results,
'KNN variants',
'n',
'accuracy',
percentage=True)
plt.show()
def plotDecisionBoundry(X, y, y_predicted, modelName):
X_Train_embedded = TSNE(n_components=2).fit_transform(X)
print(X_Train_embedded.shape)
# create meshgrid
resolution = 1000 # 100x100 background pixels
X2d_xmin, X2d_xmax = np.min(X_Train_embedded[:, 0]), np.max(
X_Train_embedded[:, 0])
X2d_ymin, X2d_ymax = np.min(X_Train_embedded[:, 1]), np.max(
X_Train_embedded[:, 1])
xx, yy = np.meshgrid(np.linspace(X2d_xmin, X2d_xmax, resolution),
np.linspace(X2d_ymin, X2d_ymax, resolution))
# approximate Voronoi tesselation on resolution x resolution grid using 1-NN
background_model = KNeighborsClassifier(n_neighbors=1).fit(
X_Train_embedded, y_predicted)
voronoiBackground = background_model.predict(np.c_[xx.ravel(), yy.ravel()])
voronoiBackground = voronoiBackground.reshape((resolution, resolution))
#plot
plt.contourf(xx, yy, voronoiBackground)
plt.scatter(X_Train_embedded[:, 0],
X_Train_embedded[:, 1],
c=y.values.flatten())
plt.title(modelName)
plt.show()
def reduce_data(self, X, y):
X, y = check_X_y(X, y, accept_sparse="csr")
if self.classifier == None:
self.classifier = KNeighborsClassifier(n_neighbors=self.n_neighbors)
if self.classifier.n_neighbors != self.n_neighbors:
self.classifier.n_neighbors = self.n_neighbors
classes = np.unique(y)
self.classes_ = classes
minority_class = self.pos_class
if self.pos_class == None:
minority_class = min(set(y), key = list(y).count)
# loading inicial groups
self.groups = []
for label in classes:
mask = y == label
self.groups = self.groups + [_Group(X[mask], label)]
self._main_loop()
self._generalization_step()
min_groups = filter(lambda g: g.label == minority_class, self.groups)
self._merge()
self._pruning()
max_groups = filter(lambda g: g.label != minority_class, self.groups)
self.groups = min_groups + max_groups
self.X_ = np.asarray([g.rep_x for g in self.groups])
self.y_ = np.asarray([g.label for g in self.groups])
self.reduction_ = 1.0 - float(len(self.y_))/len(y)
return self.X_, self.y_
def knn_builder():
pip_knn = Pipeline([("selector",SelectKBest(chi2)),("knn_clf",KNeighborsClassifier())])
parameters_knn ={'selector__k':[20],
"knn_clf__n_neighbors":[1]}
scorer_knn = make_scorer(accuracy_score)
searcher_knn = GridSearchCV(pip_knn, parameters_knn, scoring=scorer_knn)
return searcher_knn
def predict(self, X, n_neighbors=1):
"""Perform classification on an array of test vectors X.
The predicted class C for each sample in X is returned.
Parameters
----------
X : array-like, shape = [n_samples, n_features]
Returns
-------
C : array, shape = [n_samples]
Notes
-----
The default prediction is using KNeighborsClassifier, if the
instance reducition algorithm is to be performed with another
classifier, it should be explicited overwritten and explained
in the documentation.
"""
X = check_array(X)
if not hasattr(self, "X_") or self.X_ is None:
raise AttributeError("Model has not been trained yet.")
if not hasattr(self, "y_") or self.y_ is None:
raise AttributeError("Model has not been trained yet.")
if self.classifier == None:
self.classifier = KNeighborsClassifier(n_neighbors=n_neighbors)
self.classifier.fit(self.X_, self.y_)
return self.classifier.predict(X)
def get_gating(dss, tsf_name, use_gating=UseGating.TREE, *args, **kwargs):
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors.classification import KNeighborsClassifier
component_scale = [1, 0.2]
# TODO this is specific to coordinate transform to slice just the body frame reaction force
# input_slice = slice(3, None)
input_slice = None
if use_gating is UseGating.MLP:
gating = gating_function.MLPSelector(dss, *args, **kwargs, name=tsf_name, input_slice=input_slice)
elif use_gating is UseGating.KDE:
gating = gating_function.KDESelector(dss, component_scale=component_scale, input_slice=input_slice)
elif use_gating is UseGating.GMM:
opts = {'n_components': 10, }
if kwargs is not None:
opts.update(kwargs)
gating = gating_function.GMMSelector(dss, gmm_opts=opts, variational=True, component_scale=component_scale,
input_slice=input_slice)
elif use_gating is UseGating.TREE:
gating = gating_function.SklearnClassifierSelector(dss, DecisionTreeClassifier(**kwargs),
input_slice=input_slice)
elif use_gating is UseGating.FORCE:
gating = gating_function.ReactionForceHeuristicSelector(12, slice(3, None))
elif use_gating is UseGating.MLP_SKLEARN:
gating = gating_function.SklearnClassifierSelector(dss, MLPClassifier(**kwargs), input_slice=input_slice)
elif use_gating is UseGating.KNN:
gating = gating_function.SklearnClassifierSelector(dss, KNeighborsClassifier(n_neighbors=1, **kwargs),
input_slice=input_slice)
else:
raise RuntimeError("Unrecognized selector option")
return gating
def reduce_data(self, X, y):
X, y = check_X_y(X, y, accept_sparse="csr")
if self.classifier == None:
self.classifier = KNeighborsClassifier(n_neighbors=self.n_neighbors)
if self.classifier.n_neighbors != self.n_neighbors:
self.classifier.n_neighbors = self.n_neighbors
classes = np.unique(y)
self.classes_ = classes
# loading inicial groups
self.groups = []
for label in classes:
mask = y == label
self.groups = self.groups + [_Group(X[mask], label)]
self._main_loop()
self._generalization_step()
self._merge()
self._pruning()
self.X_ = np.asarray([g.rep_x for g in self.groups])
self.y_ = np.asarray([g.label for g in self.groups])
self.reduction_ = 1.0 - float(len(self.y_))/len(y)
return self.X_, self.y_
def reduce_data(self, X, y):
if self.classifier == None:
self.classifier = KNeighborsClassifier(
n_neighbors=self.n_neighbors, algorithm='brute')
if self.classifier.n_neighbors != self.n_neighbors:
self.classifier.n_neighbors = self.n_neighbors
X, y = check_arrays(X, y, sparse_format="csr")
classes = np.unique(y)
self.classes_ = classes
self.classifier.fit(X, y)
nn_idx = self.classifier.kneighbors(X,
n_neighbors=2,
return_distance=False)
nn_idx = nn_idx.T[1]
mask = [
nn_idx[nn_idx[index]] == index and y[index] != y[nn_idx[index]]
for index in xrange(nn_idx.shape[0])
]
mask = ~np.asarray(mask)
if self.keep_class != None and self.keep_class in self.classes_:
mask[y == self.keep_class] = True
self.X_ = np.asarray(X[mask])
self.y_ = np.asarray(y[mask])
self.reduction_ = 1.0 - float(len(self.y_)) / len(y)
return self.X_, self.y_
def _pruning(self):
if len(self.groups) < 2:
return self.groups
pruned, fst = False, True
knn = KNeighborsClassifier(n_neighbors = 1, algorithm='brute')
while pruned or fst:
index = 0
pruned, fst = False, False
while index < len(self.groups):
group = self.groups[index]
mask = np.ones(len(self.groups), dtype=bool)
mask[index] = False
reps_x = np.asarray([g.rep_x for g in self.groups])[mask]
reps_y = np.asarray([g.label for g in self.groups])[mask]
labels = knn.fit(reps_x, reps_y).predict(group.X)
if (labels == group.label).all():
self.groups.remove(group)
pruned = True
else:
index = index + 1
if len(self.groups) == 1:
index = len(self.groups)
pruned = False
return self.groups
def reduce_data(self, X, y):
X, y = check_arrays(X, y, sparse_format="csr")
if self.classifier == None:
self.classifier = KNeighborsClassifier(
n_neighbors=self.n_neighbors)
prots_s = []
labels_s = []
classes = np.unique(y)
self.classes_ = classes
for cur_class in classes:
mask = y == cur_class
insts = X[mask]
prots_s = prots_s + [insts[np.random.randint(0, insts.shape[0])]]
labels_s = labels_s + [cur_class]
self.classifier.fit(prots_s, labels_s)
for sample, label in zip(X, y):
if self.classifier.predict(sample) != [label]:
prots_s = prots_s + [sample]
labels_s = labels_s + [label]
self.classifier.fit(prots_s, labels_s)
self.X_ = np.asarray(prots_s)
self.y_ = np.asarray(labels_s)
self.reduction_ = 1.0 - float(len(self.y_)) / len(y)
return self.X_, self.y_
def reduce_data(self, X, y):
if self.classifier == None:
self.classifier = KNeighborsClassifier(n_neighbors=self.n_neighbors)
if self.classifier.n_neighbors != self.n_neighbors:
self.classifier.n_neighbors = self.n_neighbors
X, y = check_arrays(X, y, sparse_format="csr")
classes = np.unique(y)
self.classes_ = classes
if self.n_neighbors >= len(X):
self.X_ = np.array(X)
self.y_ = np.array(y)
self.reduction_ = 0.0
return self.X_, self.y_
mask = np.zeros(y.size, dtype=bool)
tmp_m = np.ones(y.size, dtype=bool)
for i in xrange(y.size):
tmp_m[i] = not tmp_m[i]
self.classifier.fit(X[tmp_m], y[tmp_m])
sample, label = X[i], y[i]
if self.classifier.predict(sample) == [label]:
mask[i] = not mask[i]
tmp_m[i] = not tmp_m[i]
self.X_ = np.asarray(X[mask])
self.y_ = np.asarray(y[mask])
self.reduction_ = 1.0 - float(len(self.y_)) / len(y)
return self.X_, self.y_
def _main_loop(self):
exit_count = 0
knn = KNeighborsClassifier(n_neighbors = 1, algorithm='brute')
while exit_count < len(self.groups):
index, exit_count = 0, 0
while index < len(self.groups):
group = self.groups[index]
reps_x = np.asarray([g.rep_x for g in self.groups])
reps_y = np.asarray([g.label for g in self.groups])
knn.fit(reps_x, reps_y)
nn_idx = knn.kneighbors(group.X, n_neighbors=1, return_distance=False)
nn_idx = nn_idx.T[0]
mask = nn_idx == index
# if all are correctly classified
if not (False in mask):
exit_count = exit_count + 1
# if all are misclasified
elif not (group.label in reps_y[nn_idx]):
pca = PCA(n_components=1)
pca.fit(group.X)
# maybe use a 'for' instead of creating array
d = pca.transform(reps_x[index])
dis = [pca.transform(inst)[0] for inst in group.X]
mask_split = (dis < d).flatten()
new_X = group.X[mask_split]
self.groups.append(_Group(new_X, group.label))
group.X = group.X[~mask_split]
elif (reps_y[nn_idx] == group.label).all() and (nn_idx != index).any():
mask_mv = nn_idx != index
index_mv = np.asarray(range(len(group)))[mask_mv]
X_mv = group.remove_instances(index_mv)
G_mv = nn_idx[mask_mv]
for x, g in zip(X_mv, G_mv):
self.groups[g].add_instances([x])
elif (reps_y[nn_idx] != group.label).sum()/float(len(group)) > self.r_mis:
mask_mv = reps_y[nn_idx] != group.label
new_X = group.X[mask_mv]
self.groups.append(_Group(new_X, group.label))
group.X = group.X[~mask_mv]
else:
exit_count = exit_count + 1
if len(group) == 0:
self.groups.remove(group)
else:
index = index + 1
for g in self.groups:
g.update_all()
return self.groups
def evaluate(Xtra, ytra, Xtst, ytst, k=1, positive_label=1):
knn = KNeighborsClassifier(n_neighbors=k, algorithm='brute')
knn.fit(Xtra, ytra)
y_true = ytst
y_pred = knn.predict(Xtst)
return evaluate_results(y_true, y_pred, positive_label=positive_label)
def __init__(self, csv_path_train, csv_path_test, k):
'''
Constructor
'''
self.csv_path_train = csv_path_train
self.csv_path_test = csv_path_test
self.classifier = KNeighborsClassifier(n_neighbors=k,
p=2,
metric='minkowski')
def knn(X, y, model_path):
model = KNeighborsClassifier()
model.fit(X, y)
print(model)
#预测
expected = y
predicted = model.predict(X)
print(metrics.classification_report(expected, predicted))
print(metrics.confusion_matrix(expected, predicted))
joblib.dump(model, model_path)
def setclassifier(self, estimator=KNeighborsClassifier(n_neighbors=10)):
"""Assign classifier for which decision boundary should be plotted.
Parameters
----------
estimator : BaseEstimator instance, optional (default=KNeighborsClassifier(n_neighbors=10)).
Classifier for which the decision boundary should be plotted. Must have
probability estimates enabled (i.e. estimator.predict_proba must work).
Make sure it is possible for probability estimates to get close to 0.5
(more specifically, as close as specified by acceptance_threshold).
"""
self.classifier = estimator
def run_knn_multi_level_classifier(train, train_labels):
k_range = list(range(2, 5))
k_scores = []
for k in k_range:
knn = KNeighborsClassifier(n_neighbors=k)
scores = cross_val_score(knn,
train,
train_labels,
cv=10,
scoring='accuracy')
k_scores.append(scores.mean())
return k_scores
def __init__(self, Xval, yval, K=5, weighted=False, knn=None):
self.Xval = Xval
self.yval = yval
self.K = K
if knn is None:
self.knn = KNeighborsClassifier(n_neighbors=K, algorithm='brute')
else:
self.knn = knn
self.knn.fit(Xval, yval)
self.weighted = weighted
def plot_boundaries_decision(X, y, clf, namefile):
"""
Method to plot the boundaries decision of our data
X : A numpy array of the data we want to plot
y : A numpy array of the label corresponding to our data
clf : the model use to predict the label of our data
namefile : the name of the file in which we want to save the figure
"""
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.333,
random_state=42)
# #The plot of boundary decision in the 2D space of representation of data
model.fit(X_train, y_train)
# create meshgrid
resolution = 100 # 100x100 background pixels
X2d_xmin, X2d_xmax = np.min(X[:, 0]), np.max(X[:, 0])
X2d_ymin, X2d_ymax = np.min(X[:, 1]), np.max(X[:, 1])
xx, yy = np.meshgrid(np.linspace(X2d_xmin, X2d_xmax, resolution),
np.linspace(X2d_ymin, X2d_ymax, resolution))
# approximate Voronoi tesselation on resolution x resolution grid using 1-NN
background_model = KNeighborsClassifier(n_neighbors=1).fit(X, y)
voronoiBackground = background_model.predict(np.c_[xx.ravel(), yy.ravel()])
voronoiBackground = voronoiBackground.reshape((resolution, resolution))
fig = pyplot.figure()
fig.set_size_inches(10.5, 8.5)
ax = fig.add_subplot(211) #small subplot to show how the legend has moved.
#plot
ax.contourf(xx, yy, voronoiBackground)
ax.set_title(
" Boundaries decision in using the dimensionality reduction of Multidimensional scaling"
)
ax.scatter(X[:, 0], X[:, 1], c=color[y].tolist())
label = numpy.array([x for x in ["Apple", "Tomatoes"]])
# Legend
for ind, s in enumerate(label):
ax.scatter([], [], label=s, color=color[ind])
pyplot.legend(scatterpoints=1,
frameon=True,
labelspacing=0.5,
bbox_to_anchor=(1.2, .4),
loc='center right')
pyplot.tight_layout()
pyplot.savefig(namefile)
pyplot.show()
def get_best_k(X, y, max_k=30, keep_best_n=10, weights=None):
# TODO: check X, y. description
# Set default values
if max_k is None:
max_k = len(X)
if weights is None:
weights = ['uniform', 'distance']
# Make weights into a list if it is not already one
if type(weights) is not list:
weights = [weights]
# Check if inputs are valid
check_pandas_dataframe_nd(X, 'X')
check_numpy_array_pandas_dataframe_series_1d(y, 'y')
check_list_of_strings(weights, 'weights')
check_integer(max_k, 'max_k')
check_larger(max_k, 'max_k', 1)
check_integer(keep_best_n, 'keep_best_n')
check_larger(keep_best_n, 'keep_best_n', 1)
# Change shape of y if necessary
y = np.array(y)
y = y.ravel()
# Split into train and test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)
# Get value for max_k
max_k = min(max_k, len(X_test))
# Set up results-list
best_model = []
for k in range(1, max_k):
for weight in weights:
model = KNeighborsClassifier(n_neighbors=k,
weights=weight).fit(X_train, y_train)
score = model.score(X_test, y_test)
best_model.append((k, weight, score))
best_model.sort(key=lambda x: x[2], reverse=True)
best_model = best_model[0:keep_best_n]
return best_model
def __plot_decision_boundaries(X,
y,
y_pred,
resolution: int = 100,
embedding=None):
if embedding is None:
embedding = TSNE(n_components=2, random_state=160290).fit_transform(X)
x_min, x_max = safe_bounds(embedding[:, 0])
y_min, y_max = safe_bounds(embedding[:, 1])
xx, yy = np.meshgrid(np.linspace(x_min, x_max, resolution),
np.linspace(y_min, y_max, resolution))
# approximate Voronoi tesselation on resolution x resolution grid using 1-NN
background_model = KNeighborsClassifier(n_neighbors=1).fit(
embedding, y_pred)
voronoi_bg = background_model.predict(np.c_[xx.ravel(), yy.ravel()])
voronoi_bg = voronoi_bg.reshape((resolution, resolution))
mesh = hv.QuadMesh((xx, yy, voronoi_bg)).opts(cmap="viridis")
points = hv.Scatter(
{
"x": embedding[:, 0],
"y": embedding[:, 1],
"pred": y_pred,
"class": y
},
kdims=["x", "y"],
vdims=["pred", "class"],
)
errors = y_pred != y
failed_points = hv.Scatter(
{
"x": embedding[errors, 0],
"y": embedding[errors, 1]
},
kdims=["x", "y"]).opts(color="red", size=5, alpha=0.9)
points = points.opts(color="pred",
cmap="viridis",
line_color="grey",
size=10,
alpha=0.8,
tools=["hover"])
plot = mesh * points * failed_points
plot = plot.opts(xaxis=None,
yaxis=None,
width=500,
height=450,
title="Decision boundaries on TSNE")
return plot
def get_result(self):
# file opener
tkinter.Tk().withdraw()
directory = filedialog.askdirectory()
result = self.read_emails_from_directory(directory)
train_labels = np.zeros(1430)
train_labels[715:1430] = 1
# This equates to 1-715 = HAM and 716-1430 = SPAM
# If you change result[n] to something else
# Make sure you change the same result down
# down in line 251 (test_matrix)
train_matrix = self.extract_features(directory, result[0])
#print(train_matrix)
# print("body words:", result[0])
# print("\n\nsubject words:", result[1])
# print("\n\nbody phrases:", result[2])
# print("\n\nsubject phrases:", result[3])
print("body words:", len(result[0]))
print("subject words:", len(result[1]))
print("body phrases:", len(result[2]))
print("subject phrases:", len(result[3]))
model1 = MultinomialNB()
model2 = LinearSVC()
model3 = RandomForestClassifier()
model4 = KNeighborsClassifier()
model1.fit(train_matrix, train_labels)
model2.fit(train_matrix, train_labels)
model3.fit(train_matrix, train_labels)
model4.fit(train_matrix, train_labels)
test_dir = filedialog.askdirectory()
# Here -----v
test_matrix = self.extract_features(test_dir, result[0])
test_labels = np.zeros(600)
# This equates to 1-300 = HAM and 301-600 = SPAM
test_labels[300:600] = 1
result1 = model1.predict(test_matrix)
result2 = model2.predict(test_matrix)
result3 = model3.predict(test_matrix)
result4 = model4.predict(test_matrix)
print(confusion_matrix(test_labels, result1))
print(confusion_matrix(test_labels, result2))
print(confusion_matrix(test_labels, result3))
print(confusion_matrix(test_labels, result4))
return result
def index_nearest_neighbor(self, S, X, y):
classifier = KNeighborsClassifier(n_neighbors=1)
U = []
S_mask = np.array(S, dtype=bool, copy=True)
indexs = np.asarray(range(len(y)))[S_mask]
X_tra, y_tra = X[S_mask], y[S_mask]
for i in range(len(y)):
real_indexes = np.asarray(range(len(y)))[S_mask]
X_tra, y_tra = X[S_mask], y[S_mask]
#print len(X_tra), len(y_tra)
classifier.fit(X_tra, y_tra)
[[index]] = classifier.kneighbors(X[i], return_distance=False)
U = U + [real_indexes[index]]
return U
def education():
D = load_data("teaching")
X_train, y_train, X_test, y_test = split_data(D['content'], D['class'],
0.9)
print("Обучение классификатора...")
text_clf = Pipeline([
('covect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', KNeighborsClassifier()),
])
text_clf.fit(D['content'], D['class'])
print("Accuracy: %.4f" % text_clf.score(X_test, y_test))
print("Обучение завершено")
return text_clf
def defaultModels(df_xmat, df_ymat_cat):
#### representitive common classifiers in sklearn ####
classifiers = [
GaussianNB(),
LogisticRegression(max_iter=500),
DecisionTreeClassifier(),
KNeighborsClassifier(),
SVC(kernel='rbf'),
AdaBoostClassifier(),
BaggingClassifier(),
ExtraTreesClassifier(),
GradientBoostingClassifier(),
RandomForestClassifier(),
]
cv = StratifiedKFold(n_splits=10)
res = []
for clf in classifiers:
print('processing...' + str(clf)[:10])
metrics_cv = []
for train_index, test_index in cv.split(df_xmat.values, df_ymat_cat):
X_train = df_xmat.iloc[train_index, :].values
X_test = df_xmat.iloc[test_index, :].values
y_train = [df_ymat_cat[i] for i in train_index]
y_test = [df_ymat_cat[i] for i in test_index]
clf.fit(X_train, y_train)
metrics_cv.append(clf.score(X_test, y_test))
res.append([
str(clf)[:10],
np.array(metrics_cv).mean(axis=0),
np.array(metrics_cv).std(axis=0)
])
return res
def generate_classifiers(classifiers_names):
"""Generate classifiers."""
classifiers = [('LR',
LogisticRegression(solver='lbfgs',
max_iter=1e4,
multi_class='auto'), {}),
('KNN', KNeighborsClassifier(), {
'n_neighbors': [3, 5]
}), ('DT', DecisionTreeClassifier(), {
'max_depth': [3, 6]
}),
('GBC', GradientBoostingClassifier(), {
'max_depth': [3, 6],
'n_estimators': [50, 100]
})]
if classifiers_names != 'all':
classifiers = select_pipelines(classifiers, classifiers_names)
return classifiers
def __init__(self,
n_neighbors=1,
alpha=0.6,
max_loop=1000,
threshold=0,
chromosomes_count=10):
self.n_neighbors = n_neighbors
self.alpha = alpha
self.max_loop = max_loop
self.threshold = threshold
self.chromosomes_count = chromosomes_count
self.evaluations = None
self.chromosomes = None
self.best_chromosome_ac = -1
self.best_chromosome_rd = -1
self.classifier = KNeighborsClassifier(n_neighbors=n_neighbors)
