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)
# Заполните таблицу ошибок классификации: # 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)
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)
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))
# Отнормируйте выборку с помощью функции 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))
# возвращаем лучшее значение
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))
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)
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)
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)