from shad_util import print_answer
# 1. Загрузите файл classification.csv. В нем записаны истинные классы объектов выборки (колонка true) и ответы
# некоторого классификатора (колонка predicted).
df = pandas.read_csv('classification.csv')
# 2. Заполните таблицу ошибок классификации. Для этого подсчитайте величины TP, FP, FN и TN согласно их определениям.
# Например, FP — это количество объектов, имеющих класс 0, но отнесенных алгоритмом к классу 1.
# Ответ в данном вопросе — четыре числа через пробел.
clf_table = {'tp': (1, 1), 'fp': (0, 1), 'fn': (1, 0), 'tn': (0, 0)}
for name, res in clf_table.iteritems():
clf_table[name] = len(df[(df['true'] == res[0]) & (df['pred'] == res[1])])
print_answer(1, '{tp} {fp} {fn} {tn}'.format(**clf_table))
# 3. Посчитайте основные метрики качества классификатора:
# Accuracy (доля верно угаданных) — sklearn.metrics.accuracy_score
acc = metrics.accuracy_score(df['true'], df['pred'])
# Precision (точность) — sklearn.metrics.precision_score
pr = metrics.precision_score(df['true'], df['pred'])
# Recall (полнота) — sklearn.metrics.recall_score
rec = metrics.recall_score(df['true'], df['pred'])
# F-мера — sklearn.metrics.f1_score
f1 = metrics.f1_score(df['true'], df['pred'])
vectorizer = TfidfVectorizer()
vectorizer.fit_transform(X)
# 3. Подберите минимальный лучший параметр C из множества [10^-5, 10^-4, ... 10^4, 10^5] для SVM с
# линейным ядром (kernel='linear') при помощи кросс-валидации по 5 блокам. Укажите параметр random_state=241 и для SVM,
# и для KFold. В качестве меры качества используйте долю верных ответов (accuracy).
grid = {'C': np.power(10.0, np.arange(-5, 6))}
cv = KFold(y.size, n_folds=5, shuffle=True, random_state=241)
model = SVC(kernel='linear', random_state=241)
gs = grid_search.GridSearchCV(model, grid, scoring='accuracy', cv=cv)
gs.fit(vectorizer.transform(X), y)
C = gs.best_params_.get('C')
# 4. Обучите SVM по всей выборке с оптимальным параметром C, найденным на предыдущем шаге.
model = SVC(kernel='linear', random_state=241, C=C)
model.fit(vectorizer.transform(X), y)
# 5. Найдите 10 слов с наибольшим по модулю весом. Они являются ответом на это задание. Укажите их через запятую или
# пробел, в нижнем регистре, в лексикографическом порядке.
words = vectorizer.get_feature_names()
coef = pandas.DataFrame(model.coef_.data, model.coef_.indices)
top_words = coef[0].map(lambda w: abs(w)).sort_values(
ascending=False).head(10).index.map(lambda i: words[i])
top_words.sort()
print_answer(1, ','.join(top_words))
def test_accuracy(kf, X, y):
scores = list()
k_range = xrange(1, 51)
for k in k_range:
model = KNeighborsClassifier(n_neighbors=k)
scores.append(cross_val_score(model, X, y, cv=kf, scoring='accuracy'))
return pandas.DataFrame(scores,
k_range).mean(axis=1).sort_values(ascending=False)
accuracy = test_accuracy(kf, X, y)
top_accuracy = accuracy.head(1)
print_answer(1, top_accuracy.index[0])
print_answer(2, top_accuracy.values[0])
# 5. Произведите масштабирование признаков с помощью функции sklearn.preprocessing.scale.
# Снова найдите оптимальное k на кросс-валидации.
X = sklearn.preprocessing.scale(X)
accuracy = test_accuracy(kf, X, y)
# 6. Какое значение k получилось оптимальным после приведения признаков к одному масштабу?
# Приведите ответы на вопросы 3 и 4. Помогло ли масштабирование признаков?
top_accuracy = accuracy.head(1)
print_answer(3, top_accuracy.index[0])
print_answer(4, top_accuracy.values[0])
imsave('images/mean/parrots_' + str(n_clusters) + '.jpg', mean_image)
medians = pixels.groupby('cluster').median().values
median_pixels = [medians[c] for c in pixels['cluster'].values]
median_image = np.reshape(median_pixels, (w, h, d))
imsave('images/median/parrots_' + str(n_clusters) + '.jpg', median_image)
return mean_image, median_image
# 4. Измерьте качество получившейся сегментации с помощью метрики PSNR. Эту метрику нужно реализовать
# самостоятельно (см. определение).
def psnr(image1, image2):
mse = np.mean((image1 - image2)**2)
return 10 * math.log10(float(1) / mse)
# 5. Найдите минимальное количество кластеров, при котором значение PSNR выше 20 (можно рассмотреть
# не более 20кластеров). Это число и будет ответом в данной задаче.
for n in xrange(1, 21):
mean_image, median_image = cluster(pixels, n)
psnr_mean, psnr_median = psnr(image, mean_image), psnr(image, median_image)
print psnr_mean, psnr_median
if psnr_mean > 20 or psnr_median > 20:
print_answer(1, n)
break
X = sklearn.preprocessing.scale(X)
# 3. Переберите разные варианты параметра метрики p по сетке от 1 до 10 с таким шагом, чтобы всего было протестировано
# 200 вариантов (используйте функцию numpy.linspace). Используйте KNeighborsRegressor с n_neighbors=5 и
# weights='distance' — данный параметр добавляет в алгоритм веса, зависящие от расстояния до ближайших соседей.
# В качестве метрики качества используйте среднеквадратичную ошибку (параметр scoring='mean_squared_error' у
# cross_val_score). Качество оценивайте, как и в предыдущем задании, с помощью кросс-валидации по 5 блокам с
# random_state = 42, не забудьте включить перемешивание выборки (shuffle=True).
def test_accuracy(kf, X, y):
scores = list()
p_range = linspace(1, 10, 200)
for p in p_range:
model = KNeighborsRegressor(p=p, n_neighbors=5, weights='distance')
scores.append(cross_val_score(model, X, y, cv=kf, scoring='mean_squared_error'))
return pandas.DataFrame(scores, p_range).max(axis=1).sort_values(ascending=False)
kf = KFold(len(y), n_folds=5, shuffle=True, random_state=42)
accuracy = test_accuracy(kf, X, y)
# 4. Определите, при каком p качество на кросс-валидации оказалось оптимальным (обратите внимание,
# что показатели качества, которые подсчитывает cross_val_score, необходимо максимизировать).
# Это значение параметра и будет ответом на задачу.
top_accuracy = accuracy.head(1)
print_answer(1, top_accuracy.index[0])
x_labels = ['Pclass', 'Fare', 'Age', 'Sex'] X = df.loc[:, x_labels] # 3. Обратите внимание, что признак Sex имеет строковые значения. X['Sex'] = X['Sex'].map(lambda sex: 1 if sex == 'male' else 0) # 4. Выделите целевую переменную — она записана в столбце Survived. y = df['Survived'] # 5. В данных есть пропущенные значения — например, для некоторых пассажиров неизвестен их возраст. # Такие записи при чтении их в pandas принимают значение nan. Найдите все объекты, у которых есть пропущенные признаки, # и удалите их из выборки. X = X.dropna() y = y[X.index.values] # 6. Обучите решающее дерево с параметром random_state=241 и остальными параметрами по умолчанию. clf = DecisionTreeClassifier(random_state=241) clf.fit(np.array(X.values), np.array(y.values)) # 7. Вычислите важности признаков и найдите два признака с наибольшей важностью. # Их названия будут ответами для данной задачи (в качестве ответа укажите названия признаков через запятую или пробел, # порядок не важен). importances = pandas.Series(clf.feature_importances_, index=x_labels) print_answer(1, ' '.join(importances.sort_values(ascending=False).head(2).index.values))
# Примените DictVectorizer для получения one-hot-кодирования признаков LocationNormalized и ContractTime.
enc = DictVectorizer()
X_train_cat = enc.fit_transform(train[['LocationNormalized',
'ContractTime']].to_dict('records'))
# Объедините все полученные признаки в одну матрицу "объекты-признаки". Обратите внимание, что матрицы для текстов и
# категориальных признаков являются разреженными. Для объединения их столбцов нужно воспользоваться функцией
# scipy.sparse.hstack.
X_train = hstack([X_train_text, X_train_cat])
# 3. Обучите гребневую регрессию с параметром alpha=1. Целевая переменная записана в столбце SalaryNormalized.
y_train = train['SalaryNormalized']
model = Ridge(alpha=1)
model.fit(X_train, y_train)
# 4. Постройте прогнозы для двух примеров из файла salary-test-mini.csv. Значения полученных прогнозов являются
# ответом на задание. Укажите их через пробел.
test = pandas.read_csv('salary-test-mini.csv')
X_test_text = vec.transform(text_transform(test['FullDescription']))
X_test_cat = enc.transform(test[['LocationNormalized',
'ContractTime']].to_dict('records'))
X_test = hstack([X_test_text, X_test_cat])
y_test = model.predict(X_test)
print_answer(1, '{:0.2f} {:0.2f}'.format(y_test[0], y_test[1]))
# coding=utf-8
import pandas
import re
import sys
sys.path.append("..")
from shad_util import print_answer
data = pandas.read_csv('titanic.csv', index_col='PassengerId')
data['Pclass'] = data['Pclass'].astype(object)
# 1. Какое количество мужчин и женщин ехало на корабле? В качестве ответа приведите два числа через пробел.
sex_counts = data['Sex'].value_counts()
print_answer(1, '{} {}'.format(sex_counts['male'], sex_counts['female']))
# 2. Какой части пассажиров удалось выжить? Посчитайте долю выживших пассажиров.
# Ответ приведите в процентах (число в интервале от 0 до 100, знак процента не нужен).
surv_counts = data['Survived'].value_counts()
surv_percent = 100.0 * surv_counts[1] / surv_counts.sum()
print_answer(2, "{:0.2f}".format(surv_percent))
# 3. Какую долю пассажиры первого класса составляли среди всех пассажиров?
# Ответ приведите в процентах (число в интервале от 0 до 100, знак процента не нужен).
pclass_counts = data['Pclass'].value_counts()
pclass_percent = 100.0 * pclass_counts[1] / pclass_counts.sum()
print_answer(3, "{:0.2f}".format(pclass_percent))
X_train = df_train.loc[:, 1:]
df_test = pandas.read_csv('perceptron-test.csv', header=None)
y_test = df_train[0]
X_test = df_train.loc[:, 1:]
# 2. Обучите персептрон со стандартными параметрами и random_state=241.
model = Perceptron(random_state=241)
model.fit(X_train, y_train)
# 3. Подсчитайте качество (долю правильно классифицированных объектов, accuracy) полученного классификатора
# на тестовой выборке.
# 4. Нормализуйте обучающую и тестовую выборку с помощью класса StandardScaler.
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 5. Обучите персептрон на новых выборках. Найдите долю правильных ответов на тестовой выборке.
model = Perceptron(random_state=241)
model.fit(X_train_scaled, y_train)
acc_after = accuracy_score(y_test, model.predict(X_test_scaled))
# 6. Найдите разность между качеством на тестовой выборке после нормализации и качеством до нее.
# Это число и будет ответом на задание.
print_answer(1, acc_after - acc_before)
plt.plot(test_loss, 'r', linewidth=2)
plt.plot(train_loss, 'g', linewidth=2)
plt.legend(['test', 'train'])
plt.savefig('plots/rate_' + str(learning_rate) + '.png')
min_loss_value = min(test_loss)
min_loss_index = test_loss.index(min_loss_value)
return min_loss_value, min_loss_index
def model_test(learning_rate):
model = GradientBoostingClassifier(learning_rate=learning_rate, n_estimators=250, verbose=True, random_state=241)
model.fit(X_train, y_train)
train_loss = log_loss_results(model, X_train, y_train)
test_loss = log_loss_results(model, X_test, y_test)
return plot_loss(learning_rate, test_loss, train_loss)
min_loss_results = {}
for learning_rate in [1, 0.5, 0.3, 0.2, 0.1]:
min_loss_results[learning_rate] = model_test(learning_rate)
print_answer(1, 'overfitting')
min_loss_value, min_loss_index = min_loss_results[0.2]
print_answer(2, '{:0.2f} {}'.format(min_loss_value, min_loss_index))
model = RandomForestClassifier(n_estimators=min_loss_index, random_state=241)
model.fit(X_train, y_train)
y_pred = model.predict_proba(X_test)[:, 1]
test_loss = log_loss(y_test, y_pred)
print_answer(3, test_loss)
break
else:
w1, w2 = w1_new, w2_new
return [w1_new, w2_new]
# 4. Запустите градиентный спуск и доведите до сходимости (евклидово расстояние между векторами весов на соседних
# итерациях должно быть не больше 1e-5). Рекомендуется ограничить сверху число итераций десятью тысячами.
w1, w2 = grad(y, X)
rw1, rw2 = grad(y, X, 10.0)
# 5. Какое значение принимает AUC-ROC на обучении без регуляризации и при ее использовании?
# Эти величины будут ответом на задание. Обратите внимание, что на вход функции roc_auc_score нужно подавать
# оценки вероятностей, подсчитанные обученным алгоритмом. Для этого воспользуйтесь сигмоидной функцией:
# a(x) = 1 / (1 + exp(-w1 x1 - w2 x2)).
def a(X, w1, w2):
return 1.0 / (1.0 + math.exp(-w1 * X[1] - w2 * X[2]))
y_score = X.apply(lambda x: a(x, w1, w2), axis=1)
y_rscore = X.apply(lambda x: a(x, rw1, rw2), axis=1)
auc = roc_auc_score(y, y_score)
rauc = roc_auc_score(y, y_rscore)
print_answer(1, "{:0.3f} {:0.3f}".format(auc, rauc))
import pandas
from sklearn.svm import SVC
import sys
sys.path.append("..")
from shad_util import print_answer
# 1. Загрузите выборку из файла svm-data.csv. В нем записана двумерная выборка (целевая переменная указана
# в первом столбце, признаки — во втором и третьем).
df = pandas.read_csv('svm-data.csv', header=None)
y = df[0]
X = df.loc[:, 1:]
# 2. Обучите классификатор с линейным ядром, параметром C = 100000 и random_state=241.
# Такое значение параметра нужно использовать, чтобы убедиться, что SVM работает с выборкой как с линейно разделимой.
# При более низких значениях параметра алгоритм будет настраиваться с учетом слагаемого в функционале,
# штрафующего за маленькие отступы, из-за чего результат может не совпасть с решением классической задачи SVM для
# линейно разделимой выборки.
model = SVC(kernel='linear', C=100000, random_state=241)
model.fit(X, y)
# 3. Найдите номера объектов, которые являются опорными (нумерация с единицы). Они будут являться ответом на задание.
# Обратите внимание, что в качестве ответа нужно привести номера объектов в возрастающем порядке через
# запятую или пробел. Нумерация начинается с 1.
n_sv = model.support_
n_sv.sort()
print_answer(1, ' '.join([str(n + 1) for n in n_sv]))