# Линейные методы классификации
# Метод опорных векторов
import pandas
from sklearn.svm import SVC
from source import create_answer_file
data_train = pandas.read_csv(r'..\data\svm.csv', names=['result', 'p1', 'p2'])
y_train = data_train['result']
X_train = data_train[['p1', 'p2']]
svc = SVC(C=100000, kernel='linear', random_state=241)
fit = svc.fit(X_train, y_train)
result = ' '.join(str(f) for f in (fit.support_ + 1))
create_answer_file('w3_1.txt', f'{result}')
from sklearn.decomposition import PCA
from source import create_answer_file
train_data = pandas.read_csv(r'..\data\close_prices.csv')
train_data_2 = pandas.read_csv(r'..\data\djia_index.csv')
del train_data['date']
# Метод главных компонент
pca = PCA(n_components=10)
pca.fit(train_data)
# определение кол-ва компонентов, чтобы объяснить 90% дисперсии
ratio_sum = 0
count = 0
for index, val in enumerate(pca.explained_variance_ratio_):
ratio_sum += val
if ratio_sum >= 0.90:
count = index + 1
break
x = pca.transform(train_data)
# получение коэфф. Пирсона
coeff = np.corrcoef(x[:, 0], train_data_2['^DJI'])[0, 1]
company_name = train_data.columns[np.argmax(pca.components_[0])]
create_answer_file('w4_2.txt', f'{count}')
create_answer_file('w4_3.txt', f'{coeff}')
create_answer_file('w4_4.txt', f'{company_name}')
# метрика PSNR
psnr = lambda image1, image2: 10 * np.log10(1 / (np.mean(
(image1 - image2)**2)))
# нахождение минимального количество кластеров, при котором значение PSNR выше 20
# (можно рассмотреть не более 20 кластеров)
for n_clusters in range(1, 21):
pixels = rgb_matrix.copy()
model = KMeans(n_clusters=n_clusters, init='k-means++', random_state=241)
pixels['cluster'] = model.fit_predict(pixels)
# пиксели, отнесенные в один кластер, заполняются средним цветом по кластеру
means = pixels.groupby('cluster').mean().values
mean_image = np.reshape([means[c] for c in pixels['cluster'].values],
(w, h, d))
imsave('../images/parrots_means_' + str(n_clusters) + '.jpg', mean_image)
# пиксели, отнесенные в один кластер, заполняются медианным цветом по кластеру
medians = pixels.groupby('cluster').median().values
median_image = np.reshape([medians[c] for c in pixels['cluster'].values],
(w, h, d))
imsave('../images/parrots_medians_' + str(n_clusters) + '.jpg',
median_image)
psnr_mean, psnr_median = psnr(image, mean_image), psnr(image, median_image)
if psnr_mean > 20 or psnr_median > 20:
create_answer_file('w6_1.txt', str(n_clusters))
break
data = pandas.read_csv(r'..\data\gbm-data.csv')
X = data.loc[:, 'D1':'D1776'].values
y = data['Activity'].values
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.8,
random_state=241)
min_loss_results = {
learning_rate: model_test(learning_rate)
for learning_rate in [1, 0.5, 0.3, 0.2, 0.1]
}
# переобучение (overfitting) или недообучение (underfitting) - определяется по графикам
create_answer_file('w5_2.txt', 'overfitting')
# минимальное значение log-loss и номер итерации,
# на котором оно достигается, при learning_rate = 0.2.
min_loss_value, min_loss_index = min_loss_results[0.2]
create_answer_file('w5_3.txt', '{:0.2f} {}'.format(min_loss_value,
min_loss_index))
# RandomForestClassifier с количеством деревьев, равным количеству итераций, на котором
# достигается наилучшее качество у градиентного бустинга
model = RandomForestClassifier(n_estimators=min_loss_index, random_state=241)
model.fit(X_train, y_train)
test_loss = log_loss(y_test, model.predict_proba(X_test)[:, 1])
create_answer_file('w5_4.txt', f'{test_loss}')
names=['result', 'p1', 'p2'])
data_test = pandas.read_csv(r'..\data\perceptron-test.csv',
names=['result', 'p1', 'p2'])
y_train = data_train['result']
X_train = data_train[['p1', 'p2']]
y_test = data_test['result']
X_test = data_test[['p1', 'p2']]
clf_train = Perceptron(random_state=241)
# обучение персептрона
clf_train.fit(X_train, y_train)
predictions_train = clf_train.predict(X_test)
# определение качества предсказания перцептрона
acc_score_train = accuracy_score(y_test, predictions_train)
# стандартизация признаков
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# обучение персептрона после стандартизации признаков
clf_test = Perceptron(random_state=241)
clf_test.fit(X_train_scaled, y_train)
predictions_test = clf_test.predict(X_test_scaled)
acc_score_test = accuracy_score(y_test, predictions_test)
create_answer_file('w2_6.txt', f'{round(acc_score_test - acc_score_train, 3)}')
def get_max_accuracy(precision_data):
accuracy = precision_data[0]
recall = precision_data[1]
result = [a for r, a in zip(recall, accuracy) if r >= 0.7]
return max(result)
data = pandas.read_csv(r'..\data\classification.csv')
# выборка из данных по условию и подсчёт
TP = len(data.loc[(data['true'] == 1) & (data['pred'] == 1)])
FP = len(data.loc[(data['true'] == 0) & (data['pred'] == 1)])
FN = len(data.loc[(data['true'] == 1) & (data['pred'] == 0)])
TN = len(data.loc[(data['true'] == 0) & (data['pred'] == 0)])
create_answer_file('w3_4.txt', f'{TP} {FP} {FN} {TN}')
# доля правильных ответов
accuracy_score = round(mt.accuracy_score(data['true'], data['pred']), 3)
# точность
precision_score = round(mt.precision_score(data['true'], data['pred']), 3)
# полнота
recall_score = round(mt.recall_score(data['true'], data['pred']), 3)
# F-мера
f1_score = round(mt.f1_score(data['true'], data['pred']), 3)
create_answer_file(
'w3_5.txt',
# градиентный спуск
while distance > 1e-05 and i < 10000:
sum_1 = sum_2 = 0
old_w1 = w1
old_w2 = w2
for i in range(y_len):
a = 1 - (1 / (1 + np.exp(-y[i] *
(w1 * X['p1'][i] + w2 * X['p2'][i]))))
sum_1 = sum_1 + y[i] * X['p1'][i] * a
sum_2 = sum_2 + y[i] * X['p2'][i] * a
w1 = w1 + k / y_len * sum_1 - k * C * w1
w2 = w2 + k / y_len * sum_2 - k * C * w2
distance = get_distance(old_w1, w1, old_w2, w2)
i += 1
return round(
roc_auc_score(y, 1 / (1 + np.exp(-w1 * X['p1'] - w2 * X['p2']))), 3)
data = pandas.read_csv(r'..\data\data-logistic.csv',
names=['result', 'p1', 'p2'])
y = data['result']
X = data[['p1', 'p2']]
result_1 = get_roc_auc_score(X, y, 0)
result_2 = get_roc_auc_score(X, y, 10)
create_answer_file('w3_3.txt', f'{result_1} {result_2}')
# Композиция алгоритмов
# Случайный лес
# Регрессия
import pandas
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import KFold, cross_val_score
from source import create_answer_file
data = pandas.read_csv(r'..\data\abalone.csv')
# приводим поле к числовому виду
data['Sex'] = data['Sex'].map(lambda x: 1
if x == 'M' else (-1 if x == 'F' else 0))
X = data[[col for col in data.columns if col != 'Rings']]
y = data['Rings']
for estimators_count in range(1, 51):
clf = RandomForestRegressor(n_estimators=estimators_count, random_state=1)
clf.fit(X, y)
k_fold = KFold(n_splits=5, shuffle=True, random_state=1)
scores = cross_val_score(clf, X, y, cv=k_fold, scoring='r2')
if scores.mean() > 0.52:
create_answer_file('w5_1.txt', f'{estimators_count}')
break
means.append(scores.mean())
return means
data = pandas.read_csv(r'..\data\wine.data',
names=[
'sort', 'Alcohol', 'acid', 'Ash', 'Alcalinity',
'Magnesium', 'phenols', 'Flavanoids',
'Nonflavanoid', 'Proanthocyanins', 'intensity',
'Hue', 'diluted', 'Proline'
])
y = data['sort']
X = data[[
'Alcohol', 'acid', 'Ash', 'Alcalinity', 'Magnesium', 'phenols',
'Flavanoids', 'Nonflavanoid', 'Proanthocyanins', 'intensity', 'Hue',
'diluted', 'Proline'
]]
result = get_means(X, y)
max_mean = max(result)
create_answer_file('w2_1.txt', f'{result.index(max_mean) + 1}')
create_answer_file('w2_2.txt', f'{max_mean}')
# с маштабированием
X_scale = scale(X)
result_scale = get_means(X_scale, y)
max_mean_scale = max(result_scale)
create_answer_file('w2_3.txt', f'{result_scale.index(max_mean_scale) + 1}')
create_answer_file('w2_4.txt', f'{max_mean_scale}')
label = LabelEncoder()
dicts = {}
# задаем список значений для кодирования
label.fit(data.Sex.drop_duplicates())
dicts['Sex'] = list(label.classes_)
# заменяем значения из списка кодами закодированных элементов
data.Sex = label.transform(data.Sex)
# получение столбцов - признаков
props_columns = ['Pclass', 'Fare', 'Age', 'Sex']
x = data[props_columns]
# замена null-значения на 0
x = x.fillna(0)
# получение столбца результатов
result_column = ['Survived']
y = data[result_column]
# построение решающего дерева и обучение
tree = DecisionTreeClassifier(random_state=241)
tree.fit(x, y)
# получение важности каждого из столбцов
feature_importances = list(tree.feature_importances_)
# 2 столбца, влияющие больше всего на итоговый результат
ind1, ind2 = tree.feature_importances_.argsort()[-2:]
create_answer_file('w1_7.txt', f'{props_columns[ind1]} {props_columns[ind2]}')
train_data['LocationNormalized'] = handle(train_data['LocationNormalized'])
train_data['ContractTime'] = handle(train_data['ContractTime'])
# числовое представление слов методом TF-IDF
vector = TfidfVectorizer(min_df=5)
x_train_vector = vector.fit_transform(train_data['FullDescription'])
x_test_vector = vector.transform(test_data['FullDescription'])
# замена пропущенных значений на специальные строковые величины('nan')
train_data['LocationNormalized'].fillna('nan', inplace=True)
train_data['ContractTime'].fillna('nan', inplace=True)
# признаки LocationNormalized и ContractTime являются строковыми,
# и поэтому с ними нельзя работать напрямую - используем DictVectorizer
enc = DictVectorizer()
X_train_categ = enc.fit_transform(
train_data[['LocationNormalized', 'ContractTime']].to_dict('records'))
X_test_categ = enc.transform(test_data[['LocationNormalized',
'ContractTime']].to_dict('records'))
# объединение данных
X_train = hstack([x_train_vector, X_train_categ])
X_test = hstack([x_test_vector, X_test_categ])
# обучение модели
clf = Ridge(alpha=1, random_state=241)
clf.fit(X_train, train_data['SalaryNormalized'])
# определение SalaryNormalized для тестовых данных
result = clf.predict(X_test)
create_answer_file('w4_1.txt', f'{round(result[0],2)} {round(result[1],2)}')
from sklearn.neighbors import KNeighborsRegressor
from sklearn.preprocessing import scale
from source import create_answer_file
boston_data = load_boston()
X = boston_data.data
y = boston_data.target
# с маштабированием
X_scale = scale(X)
result_scale = []
result_p = []
for p in np.linspace(1, 10, num=200):
# определили классификатор
clf = KNeighborsRegressor(n_neighbors=5, weights='distance', p=p)
# определили разбиение
k_fold = KFold(n_splits=5, shuffle=True, random_state=42)
# проверяем как хорошо для каждого разбиения происходят предсказания
scores_scale = cross_val_score(clf,
X_scale,
y,
cv=k_fold,
scoring='mean_squared_error')
result_scale.append(scores_scale.mean())
result_p.append(p)
max_mean_scale = max(result_scale)
create_answer_file('w2_5.txt',
f'{result_p[result_scale.index(max_mean_scale)]}')