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]))