Esempio n. 1
0
labels = newsgroups.target

# Вычислите TF-IDF-признаки для всех текстов.
vec = TfidfVectorizer()
features = vec.fit_transform(texts)

# Подберите минимальный лучший параметр C из множества [10^-5, 10^-4, ... 10^4, 10^5] для SVM с линейным ядром
# и параметром random_state=241 при помощи кросс-валидации по 5 блокам.
c_values = numpy.apply_along_axis(lambda x: pow(10.0, x), 0, numpy.arange(-5, 6))
tuned_parameters = [{'C': c_values}]

clf_svc = SVC(kernel='linear', random_state=241)
clf = GridSearchCV(clf_svc, tuned_parameters, cv=5)
# clf.fit(features, labels)

# Обучите SVM по всей выборке с лучшим параметром C, найденным на предыдущем шаге.
best_c = 10 # clf.best_params_['C']
best_clf = SVC(kernel='linear', C=best_c, random_state=241)
best_clf.fit(features, labels)

# Найдите 10 слов с наибольшим по модулю весом. Они являются ответом на это задание.
# Укажите их через запятую или пробел, в нижнем регистре, в лексикографическом порядке.
best_coef_idx = numpy.absolute(numpy.asarray(best_clf.coef_.todense())).argsort().reshape(-1)[-10:][::-1]

best_words = [vec.get_feature_names()[i] for i in best_coef_idx]
best_words.sort()
res = ",".join(best_words)

print res
save_res(task_num, 1, res)
Esempio n. 2
0
# Заполните таблицу ошибок классификации:
# Actual Positive	Actual Negative
# Predicted Positive	TP	FP
# Predicted Negative	FN	TN

# Для этого подсчитайте величины TP, FP, FN и TN согласно их определениям.
# Например, FP — это количество объектов, имеющих класс 0, но отнесенных алгоритмом к классу 1.
# Ответ в данном вопросе — четыре числа через пробел.
TP = (numpy.logical_and(true, pred) == True).value_counts()[True]
FP = (numpy.logical_and(numpy.logical_not(true), pred) == True).value_counts()[True]
FN = (numpy.logical_and(true, numpy.logical_not(pred)) == True).value_counts()[True]
TN = (numpy.logical_and(numpy.logical_not(true), numpy.logical_not(pred)) == True).value_counts()[True]

res_1 = str(TP) + " " + str(FP) + " " + str(FN) + " " + str(TN)
print res_1
save_res(task_num, 1, res_1)

# Посчитайте основные метрики качества классификатора:
# Accuracy (доля верно угаданных) — sklearn.metrics.accuracy_score
# Precision (точность) — sklearn.metrics.precision_score
# Recall (полнота) — sklearn.metrics.recall_score
# F-мера — sklearn.metrics.f1_score

a = round(accuracy_score(true, pred), 2)
p = round(precision_score(true, pred), 2)
r = round(recall_score(true, pred), 2)
f = round(f1_score(true, pred), 2)

res_2 = str(a) + " " + str(p) + " " + str(r) + " " + str(f)
print res_2
save_res(task_num, 2, res_2)
Esempio n. 3
0
pca = PCA(n_components=10)
pca.fit(prices)

# Скольких компонент хватит, чтобы объяснить 90% дисперсии?
percent_90 = 0
sum_var = 0
component_count = 0
for v in pca.explained_variance_ratio_:
    sum_var += v
    component_count += 1
    if sum_var >= 0.9:
        percent_90 = component_count
        break

print percent_90
save_res(task_num, 1, percent_90)

# Примените построенное преобразование к исходным данным и возьмите значения первой компоненты.
proj = pca.transform(prices)

# Загрузите информацию об индексе Доу-Джонса из файла djia_index.csv.
jia = pandas.read_csv('../../../data/task11/jia_index.csv')['^DJI']

# Чему равна корреляция Пирсона между первой компонентой и индексом Доу-Джонса?
corr = round(corrcoef(proj[:, 0], jia)[1, 0], 2)
print(corr)
save_res(task_num, 2, corr)

# Какая компания имеет наибольший вес в первой компоненте? Укажите ее название с большой буквы.
c_name = prices.columns.values[pca.components_[0].argmax()]
print(c_name)
Esempio n. 4
0
    plt.plot(test_loss, 'r', linewidth=2)
    plt.plot(train_loss, 'g', linewidth=2)
    plt.legend(['test', 'train'])
    plt.show()

    # 4. Приведите минимальное значение log-loss и номер итерации, на котором оно достигается, при learning_rate = 0.2.
    if lr == 0.2:
        res_min_loss = test_min_loss
        res_min_iter = test_min_iter

# 3. Как можно охарактеризовать график качества на тестовой выборке, начиная с некоторой итерации:
# переобучение (overfitting) или недообучение (underfitting)?
# В ответе укажите одно из слов overfitting либо underfitting.
res = "overfitting"
print res
save_res(task_num, 1, res)

res = str(round(res_min_loss, 2)) + " " + str(res_min_iter)
print res
save_res(task_num, 2, res)

# 5. На этих же данных обучите RandomForestClassifier с количеством деревьев, равным количеству итераций,
# на котором достигается наилучшее качество у градиентного бустинга из предыдущего пункта, c random_state=241 и
#  остальными параметрами по умолчанию. Какое значение log-loss на тесте получается у этого случайного леса?
# (Не забывайте, что предсказания нужно получать с помощью функции predict_proba)
clf = RandomForestClassifier(n_estimators=res_min_iter, random_state=241)
clf.fit(X_train, y_train)
y_proba = clf.predict_proba(X_test)[:, 1]
rf_loss = log_loss(y_test, y_proba)

res = str(round(rf_loss, 2))
Esempio n. 5
0
# Отнормируйте выборку с помощью функции sklearn.preprocessing.scale.
# производим нормализацию признаков
features = scale(features)

# Переберите разные варианты параметра метрики p по сетке от 1 до 10 с таким шагом,
#  чтобы всего было протестировано 200 вариантов (используйте функцию numpy.linspace).
# Используйте KNeighborsRegressor с n_neighbors=5 и weights='distance' — данный параметр добавляет в алгоритм веса,
#  зависящие от расстояния до ближайших соседей.
# В качестве метрики качества используйте среднеквадратичную ошибку
#  (параметр scoring='mean_squared_error' у cross_val_score).
# Качество оценивайте, как и в предыдущем задании, с помощью кросс-валидации по 5 блокам с random_state = 42.

best_p = None
best_score = None
for p in linspace(1, 10, 200):
    clf = KNeighborsRegressor(n_neighbors=5, weights='distance', p=p)
    clf.fit(features, prices)

    kf = KFold(len(prices), n_folds=5, random_state=42)
    scores = cross_val_score(clf, features, prices, cv=kf, scoring='mean_squared_error')

    if best_score is None or best_score < scores.mean():
        best_p = p
        best_score = scores.mean()

# Определите, при каком p качество на кросс-валидации оказалось оптимальным
# (обратите внимание, что показатели качества, которые подсчитывает cross_val_score, необходимо максимизировать).
#  Это значение параметра и будет ответом на задачу.
print best_p
save_res(4, 1, round(best_p, 1))
Esempio n. 6
0
    # возвращаем лучшее значение
    return result_scores[0]


# классы
labels = data.ix[:, 0]

# признаки
features = data.ix[:, 1:]

# При каком k получилось оптимальное качество? Чему оно равно (число в интервале от 0 до 1)?
# Данные результаты и будут ответами для вопросов 1 и 2
best_k, best_score = find_best_param(labels, features)
print best_k
save_res(3, 1, best_k)
print best_score
save_res(3, 2, round(best_score, 2))

# Произведите нормировку признаков с помощью функции sklearn.preprocessing.scale.
#  Снова найдите оптимальное k на кросс-валидации.
# Это k, а также значение качества при нем (число в интервале от 0 до 1), будут ответами для вопросов 3 и 4.

# производим нормализацию признаков
features = scale(features)

best_k, best_score = find_best_param(labels, features)
print best_k
save_res(3, 3, best_k)
print best_score
save_res(3, 4, round(best_score, 2))
Esempio n. 7
0
from sklearn.svm import SVC

from ad4.utils.utils import save_res

task_num = 6

# Загрузите выборку из файла svm-data.csv.
# В нем записана двумерная выборка (целевая переменная указана в первом столбце, признаки — во втором и третьем).
data = pandas.read_csv('../../../data/task6/svm-data.csv', header=None)

# features and labels
data_features = data[[1, 2]]
data_labels = numpy.ravel(data[[0]])

# Обучите классификатор с линейным ядром, параметром C = 100000 и random_state=241.
# Такое значение параметра нужно использовать, чтобы убедиться, что SVM работает с выборкой как с линейно разделимой.
# При более низких значениях параметра алгоритм будет настраиваться с учетом слагаемого в функционале,
# штрафующего за маленькие отступы, из-за чего результат может не совпасть с решением классической задачи SVM
# для линейно разделимой выборки.
clf = SVC(kernel='linear', C=100000, random_state=241)
clf.fit(data_features, data_labels)

# Найдите номера объектов, которые являются опорными (нумерация с единицы).
# Они будут являться ответом на задание.
# Обратите внимание, что в качестве ответа нужно привести номера объектов
# в возрастающем порядке через запятую или пробел. Нумерация начинается с 1.
sv = " ".join(map(lambda i: str(i + 1), clf.support_.tolist()))
print sv
save_res(task_num, 1, sv)
Esempio n. 8
0
def get_accuracy(_data_train_features, _data_train_labels, _data_test_features, _data_test_labels):
    # Обучите персептрон со стандартными параметрами и random_state=241.
    clf = Perceptron(random_state=241, shuffle=True)
    clf.fit(_data_train_features, numpy.ravel(_data_train_labels))

    # Подсчитайте качество (долю правильно классифицированных объектов, accuracy)
    # полученного классификатора на тестовой выборке.
    predictions = clf.predict(_data_test_features)
    score = accuracy_score(_data_test_labels, predictions)
    return score


accuracy = get_accuracy(data_train_features, data_train_labels, data_test_features, data_test_labels)
print accuracy

# Нормализуйте обучающую и тестовую выборку с помощью класса StandardScaler.
scaler = StandardScaler()
data_train_features_scaled = scaler.fit_transform(data_train_features)
data_test_features_scaled = scaler.transform(data_test_features)

# Обучите персептрон на новых выборках. Найдите долю правильных ответов на тестовой выборке.
accuracy_stand = get_accuracy(data_train_features_scaled, data_train_labels, data_test_features_scaled,
                              data_test_labels)
print accuracy_stand

# Найдите разность между качеством на тестовой выборке после нормализации и качеством до нее.
# Это число и будет ответом на задание.
result = round(accuracy_stand - accuracy, 3)
print result
save_res(task_num, 1, result)
Esempio n. 9
0
print data[:10]

# первые 5 строк данных
print data.head()

# доступ к определенному столбцу данных
print data['Pclass']

# group by and count по столбцу
print data['Pclass'].value_counts()

# Какое количество мужчин и женщин ехало на корабле? В качестве ответа приведите два числа через пробел.
sex_counts = data['Sex'].value_counts()
res1 = str(sex_counts["male"]) + " " + str(sex_counts["female"])
print res1
save_res(task_num, 1, res1)

# Какой части пассажиров удалось выжить? Посчитайте долю выживших пассажиров.
# Ответ приведите в процентах (знак процента не нужен).
survived_counts = data['Survived'].value_counts()
res2 = round(100. * survived_counts[1] / len(data), 2)
print res2
save_res(task_num, 2, res2)

# Какую долю пассажиры первого класса составляли среди всех пассажиров?
# Ответ приведите в процентах (знак процента не нужен).
pclass_counts = data['Pclass'].value_counts()
res3 = round(100. * pclass_counts[1] / len(data), 2)
print res3
save_res(task_num, 3, res3)