Formal explanation for the sensitivity of AdaBoost to outliers

 Формальное объяснение чувствительности AdaBoost к выбросам

Рассмотрим контролируемую задачу с целевыми значениями y, равными -1 или 1. Допустим, мы подбираем функцию f(x) с помощью  классификатора AdaBoost. Интуитивно нам нужны положительные поля, где поле определяется как yi*f(xi). Положительный запас означает, что мы правильно классифицировали эту выборку, поскольку знаки f и y одинаковы. Отрицательный запас означает, что мы неправильно классифицировали выборку.  Функция потерь для Adaboost определяется как экспоненциальная:

L(y,f (x)) = exp (−y*f(x))

Эта экспонента затем приводит к более сильному наказанию точек с большим отрицательным запасом (т.е. Выбросами), чем другие классификаторы. График зависимости функции потерь от маржи для нескольких классификаторов:

Adaboost подвержен переобучению выбросов из-за формы своей функции потерь.

What is the most pythonic way to iterate over a list piece by piece

 (.env) boris@boris-All-Series:~/VOTING/CHUNK$ cat sliceListing.py

def slicer(sequence, size):

    return (sequence[j:j + size] for j in range(0, len(sequence), size))

text = "It seems to me this manual is quite useless"

for banch in slicer(text, 9):

   print(repr(banch),)

print ('^'.join(slicer(text, 12)))

arg_list = ['linux','GNU','public','license','gcc','g++','python']

for banch in slicer(arg_list, 2):

    print(banch)

(.env) boris@boris-All-Series:~/VOTING/CHUNK$ python3 sliceListing.py

'It seems '

'to me thi'

's manual '

'is quite '

'useless'

It seems to ^me this manu^al is quite ^useless

['linux', 'GNU']

['public', 'license']

['gcc', 'g++']

['python']

What is common between the core in nonparametric regression and the core of SVM

 SVM-регрессия

Алгоритм SVM довольно универсален: он не только поддерживает линейную и нелинейную классификацию, но также поддерживает линейную и нелинейную регрессию. Хитрость заключается в том, чтобы изменить цель: вместо того, чтобы пытаться разместить максимально возможную улицу между двумя классами, ограничивая нарушения маржи, регрессия SVM пытается разместить как можно больше экземпляров на улице, ограничивая нарушения маржи (т.е. экземпляры за пределами улицы). . Ширина улицы контролируется определенным гиперпараметром .

Пример SVR(kernel='poly')

В машинном обучении полиномиальное ядро
является функцией ядра, обычно используемой с машинами опорных векторов (SVM) и другими ядерными моделями, которая представляет подобие векторов (обучающих выборок) в пространстве признаков над полиномами исходных переменных, позволяя изучать не-линейные модели. Интуитивно полиномиальное ядро рассматривает не только заданные характеристики входных выборок, чтобы определить их сходство, но и их комбинации. В контексте регрессионного анализа такие комбинации известны как признаки взаимодействия. Неявное пространство признаков полиномиального ядра эквивалентно пространству полиномиальной регрессии, но без комбинаторного увеличения количества параметров, которые необходимо изучить.

=====================

SVM-Regression sample

=====================

(.env) boris@boris-All-Series:~/VOTING/SVMREGRESSION$ cat SvmRegression.py

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

import warnings

warnings.filterwarnings("ignore")

# get the dataset

dataset = pd.read_csv('./Position_Salaries.csv')

print(dataset)

# split the data into featutes and target variable seperately

X_l = dataset.iloc[:, 1:-1].values # features set

y_p = dataset.iloc[:, -1].values # set of study variable

y_p = y_p.reshape(-1,1)

from sklearn.preprocessing import StandardScaler

StdS_X = StandardScaler()

StdS_y = StandardScaler()

X_l = StdS_X.fit_transform(X_l)

y_p = StdS_y.fit_transform(y_p)

# import the model

from sklearn.svm import SVR

# create the model object

regressor = SVR(kernel = 'rbf')

# fit the model on the data

regressor.fit(X_l, y_p)

# inverse the transformation to go back to the initial scale

plt.scatter(StdS_X.inverse_transform(X_l), StdS_y.inverse_transform(y_p), color = 'red')

plt.plot(StdS_X.inverse_transform(X_l), StdS_y.inverse_transform(regressor.predict(X_l).reshape(-1,1)), color = 'blue')

# add the title to the plot

plt.title('Support Vector Regression Model')

# label x axis

plt.xlabel('Position')

# label y axis

plt.ylabel('Salary Level')

# print the plot

plt.show()

(.env) boris@boris-All-Series:~/VOTING/SVMREGRESSION$ cat  plot_svm_regression.py

"""

==============================================

Support Vector Regression (SVR) using linear and non-linear kernels

==============================================

"""

import numpy as np

from sklearn.svm import SVR

import matplotlib.pyplot as plt

# Generate sample data

X = np.sort(5 * np.random.rand(40, 1), axis=0)

y = np.sin(X).ravel()

# add noise to targets

y[::5] += 3 * (0.5 - np.random.rand(8))

# Fit regression model

svr_rbf = SVR(kernel="rbf", C=100, gamma=0.1, epsilon=0.1)

svr_lin = SVR(kernel="linear", C=100, gamma="auto")

svr_poly = SVR(kernel="poly", C=100, gamma="auto", degree=3, epsilon=0.1, coef0=1)

# Look at the results

lw = 2

svrs = [svr_rbf, svr_lin, svr_poly]

kernel_label = ["RBF", "Linear", "Polynomial"]

model_color = ["m", "c", "g"]

fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(15, 10), sharey=True)

for ix, svr in enumerate(svrs):

    axes[ix].plot(

        X,

        svr.fit(X, y).predict(X),

        color=model_color[ix],

        lw=lw,

        label="{} model".format(kernel_label[ix]),

    )

    axes[ix].scatter(

        X[svr.support_],

        y[svr.support_],

        facecolor="none",

        edgecolor=model_color[ix],

        s=50,

        label="{} support vectors".format(kernel_label[ix]),

    )

    axes[ix].scatter(

        X[np.setdiff1d(np.arange(len(X)), svr.support_)],

        y[np.setdiff1d(np.arange(len(X)), svr.support_)],

        facecolor="none",

        edgecolor="k",

        s=50,

        label="other training data",

    )

    axes[ix].legend(

        loc="upper center",

        bbox_to_anchor=(0.5, 1.1),

        ncol=1,

        fancybox=True,

        shadow=True,

    )

fig.text(0.5, 0.04, "data", ha="center", va="center")

fig.text(0.06, 0.5, "target", ha="center", va="center", rotation="vertical")

fig.suptitle("Support Vector Regression", fontsize=14)

plt.show()

=====================

SVM-Classification sample

=====================

import matplotlib.pyplot as plt

from sklearn import svm, datasets

from sklearn.inspection import DecisionBoundaryDisplay

# import some data to play with

iris = datasets.load_iris()

# Take the first two features. We could avoid this by using a two-dim dataset

X = iris.data[:, :2]

y = iris.target

# we create an instance of SVM and fit out data. We do not scale our

# data since we want to plot the support vectors

C = 1.0  # SVM regularization parameter

models = (

    svm.SVC(kernel="rbf", gamma=0.7, C=C),

    svm.SVC(kernel="poly", degree=3, gamma="auto", C=C),

)

models = (clf.fit(X, y) for clf in models)

# title for the plots

titles = (

    "SVC with RBF kernel",

    "SVC with polynomial (degree 3) kernel",

)

# Set-up 2x1 grid for plotting.

fig, sub = plt.subplots(2, 1)

plt.subplots_adjust(wspace=0.4, hspace=0.4)

X0, X1 = X[:, 0], X[:, 1]

for clf, title, ax in zip(models, titles, sub.flatten()):

    disp = DecisionBoundaryDisplay.from_estimator(

        clf,

        X,

        response_method="predict",

        cmap=plt.cm.coolwarm,

        alpha=0.8,

        ax=ax,

        xlabel=iris.feature_names[0],

        ylabel=iris.feature_names[1],

    )

    ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=20, edgecolors="k")

    ax.set_xticks(())

    ax.set_yticks(())

    ax.set_title(title)

plt.show()

Следующие команды языка программирования R используют функцию npreg() для обеспечения оптимального сглаживания и создания решения задачи непараметрической регрессии

install.packages("np")

library(np) # non parametric library

data(cps71)

attach(cps71)

m <- npreg(logwage~age)

plot(m, plot.errors.method="asymptotic",

     plot.errors.style="band",

     ylim=c(11, 15.2))

points(age, logwage, cex=.25)

На R-плоте свеху показана предполагаемая функция регрессии с использованием ядра Гаусса второго порядка вместе с границами асимптотической изменчивости.

Receiver Operating Characteristic (ROC)

 Кривые ROC обычно показывают истинное положительное значение по оси Y и ложноположительное значение по оси X. Это означает, что верхний левый угол графика является «идеальной» точкой — ложноположительный показатель равен нулю, а истинно положительный показатель равен единице. Это не очень реалистично, но это означает, что большая площадь под кривой (AUC) обычно лучше.

«Крутизна» ROC-кривых также важна, поскольку она идеальна для максимизации истинно положительного уровня при минимизации ложноположительного уровня.Кривые ROC обычно используются в двоичной классификации для изучения выходных данных классификатора. Чтобы расширить кривую ROC и область ROC до классификации с несколькими метками, необходимо бинаризировать выходные данные. Для каждой метки можно построить одну ROC-кривую, но можно также построить ROC-кривую, рассматривая каждый элемент матрицы индикатора метки как бинарное предсказание (микроусреднение).Другой мерой оценки для классификации с несколькими метками является макроусреднение, придающее равный вес классификации каждой метки.

(.env) boris@boris-All-Series:~/VOTING/ROCURVE$ cat plottingROC.py

"""

=======================================

Receiver Operating Characteristic (ROC)

=======================================

Кривые OC обычно показывают истинную положительную скорость по оси Y и ложную

положительная скорость по оси X. Это означает, что верхний левый угол графика

"идеальная" точка - ложноположительный показатель нуля и истинно положительный 

показатель один. Это не очень реалистично, но это означает, что большая площадь под

кривой (AUC) обычно лучше.«Крутизна» ROC-кривых также важна, так как она идеальна 

для максимизации истинная положительная скорость при минимизации ложноположительной скорости.

Кривые ROC обычно используются в двоичной классификации для изучения выходных данных

классификатор. Чтобы расширить кривую ROC и область ROC до нескольких меток

классификации необходимо бинаризировать вывод. Один ОКР

кривую можно нарисовать для каждой метки, но можно также нарисовать кривую ROC, учитывая

каждый элемент матрицы индикатора метки как бинарное предсказание (микроусреднение).

Еще одна оценочная мера для классификации с несколькими метками макроусреднение, 

придающее равный вес классификации каждой  этикетки.

"""

import numpy as np

import matplotlib.pyplot as plt

from itertools import cycle

from sklearn import svm, datasets

from sklearn.metrics import roc_curve, auc

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import label_binarize

from sklearn.multiclass import OneVsRestClassifier

from sklearn.metrics import roc_auc_score

# Import some data to play with

iris = datasets.load_iris()

X = iris.data

y = iris.target

# Binarize the output

y = label_binarize(y, classes=[0, 1, 2])

n_classes = y.shape[1]

# Add noisy features to make the problem harder

random_state = np.random.RandomState(0)

n_samples, n_features = X.shape

X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]

# shuffle and split training and test sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)

# Learn to predict each class against the other

classifier = OneVsRestClassifier(

    svm.SVC(kernel="linear", probability=True, random_state=random_state)

)

y_score = classifier.fit(X_train, y_train).decision_function(X_test)

# Compute ROC curve and ROC area for each class

fpr = dict()

tpr = dict()

roc_auc = dict()

for i in range(n_classes):

    fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i])

    roc_auc[i] = auc(fpr[i], tpr[i])

# Compute micro-average ROC curve and ROC area

fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel())

roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])

# Plot of a ROC curve for a specific class

plt.figure()

lw = 2

plt.plot(

    fpr[2],

    tpr[2],

    color="darkorange",

    lw=lw,

    label="ROC curve (area = %0.2f)" % roc_auc[2],

)

plt.plot([0, 1], [0, 1], color="navy", lw=lw, linestyle="--")

plt.xlim([0.0, 1.0])

plt.ylim([0.0, 1.05])

plt.xlabel("False Positive Rate")

plt.ylabel("True Positive Rate")

plt.title("Receiver operating characteristic example")

plt.legend(loc="lower right")

plt.show()

# Plot ROC curves for the multiclass problem

# Compute macro-average ROC curve and ROC area

# First aggregate all false positive rates

all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))

# Then interpolate all ROC curves at this points

mean_tpr = np.zeros_like(all_fpr)

for i in range(n_classes):

    mean_tpr += np.interp(all_fpr, fpr[i], tpr[i])

# Finally average it and compute AUC

mean_tpr /= n_classes

fpr["macro"] = all_fpr

tpr["macro"] = mean_tpr

roc_auc["macro"] = auc(fpr["macro"], tpr["macro"])

# Plot all ROC curves

plt.figure()

plt.plot(

    fpr["micro"],

    tpr["micro"],

    label="micro-average ROC curve (area = {0:0.2f})".format(roc_auc["micro"]),

    color="deeppink",

    linestyle=":",

    linewidth=4,

)

plt.plot(

    fpr["macro"],

    tpr["macro"],

    label="macro-average ROC curve (area = {0:0.2f})".format(roc_auc["macro"]),

    color="navy",

    linestyle=":",

    linewidth=4,

)

colors = cycle(["aqua", "darkorange", "cornflowerblue"])

for i, color in zip(range(n_classes), colors):

    plt.plot(

        fpr[i],

        tpr[i],

        color=color,

        lw=lw,

        label="ROC curve of class {0} (area = {1:0.2f})".format(i, roc_auc[i]),

    )

plt.plot([0, 1], [0, 1], "k--", lw=lw)

plt.xlim([0.0, 1.0])

plt.ylim([0.0, 1.05])

plt.xlabel("False Positive Rate")

plt.ylabel("True Positive Rate")

plt.title("Some extension of Receiver operating characteristic to multiclass")

plt.legend(loc="lower right")

plt.show()

# Area under ROC for the multiclass problem

# The :func:`sklearn.metrics.roc_auc_score` function can be used for

# multi-class classification. The multi-class One-vs-One scheme compares every

# unique pairwise combination of classes. In this section, we calculate the AUC

# using the OvR and OvO schemes. We report a macro average, and a prevalence-weighted average.

y_prob = classifier.predict_proba(X_test)

macro_roc_auc_ovo = roc_auc_score(y_test, y_prob, multi_class="ovo", average="macro")

weighted_roc_auc_ovo = roc_auc_score( y_test, y_prob, multi_class="ovo", average="weighted")

macro_roc_auc_ovr = roc_auc_score(y_test, y_prob, multi_class="ovr", average="macro")

weighted_roc_auc_ovr = roc_auc_score( y_test, y_prob, multi_class="ovr", average="weighted")

print( "One-vs-One ROC AUC scores:\n{:.6f} (macro),\n{:.6f} "  "(weighted by prevalence)".format(macro_roc_auc_ovo, weighted_roc_auc_ovo))

print( "One-vs-Rest ROC AUC scores:\n{:.6f} (macro),\n{:.6f} "  "(weighted by prevalence)".format(macro_roc_auc_ovr, weighted_roc_auc_ovr))

Plot 2D FEM results using matplotlib

 Метод конечных элементов (FEM) используется в различных задачах, таких как моделирование различных типов материалов, тестирование сложной геометрии, визуализация локальных эффектов, действующих на небольшой площади конструкции. Он в основном разбивает большую пространственную область на простые части, называемые «конечными элементами». Простые уравнения, которые моделируют эти конечные элементы, затем собираются в более крупную систему уравнений для моделирования всей области.

======================================

Это решение основано на matplotlib.pyplot.tricontourf().

В matplotlib нет простого способа построения заполненных контуров, если в вашей конечно-элементной сетке есть четырехугольники или элементы более высокого порядка. Для того, чтобы построить контуры, все элементы нужно сначала "разрезать" на треугольники, например, четырехугольник можно разбить или разрезать на 2 треугольника и так далее. Также необходимо использовать пользовательский метод построения линий сетки, поскольку matplotlib.pyplot.tricontourf() работает только с треугольной grid/mesh.  Для этого использовался matplotlib.pyplot.fill().

(.env) boris@boris-All-Series:~/VOTING/FEM$ cat plottingFEM1.py

import matplotlib.pyplot as plt

import matplotlib.tri as tri

# converts quad elements into tri elements

def quads_to_tris(quads):

    tris = [[None for j in range(3)] for i in range(2*len(quads))]

    for i in range(len(quads)):

        j = 2*i

        n0 = quads[i][0]

        n1 = quads[i][1]

        n2 = quads[i][2]

        n3 = quads[i][3]

        tris[j][0] = n0

        tris[j][1] = n1

        tris[j][2] = n2

        tris[j + 1][0] = n2

        tris[j + 1][1] = n3

        tris[j + 1][2] = n0

    return tris

# plots a finite element mesh

def plot_fem_mesh(nodes_x, nodes_y, elements):

    for element in elements:

        x = [nodes_x[element[i]] for i in range(len(element))]

        y = [nodes_y[element[i]] for i in range(len(element))]

        plt.fill(x, y, edgecolor='black', fill=False)

# FEM data

nodes_x = [0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0]

nodes_y = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0]

nodal_values = [1.0, 0.9, 1.1, 0.9, 2.1, 2.1, 0.9, 1.0, 1.0, 0.9, 0.8]

elements_tris = [[2, 6, 5], [5, 6, 10], [10, 9, 5]]

elements_quads = [[0, 1, 4, 3], [1, 2, 5, 4], [3, 4, 8, 7], [4, 5, 9, 8]]

elements = elements_tris + elements_quads

# convert all elements into triangles

elements_all_tris = elements_tris + quads_to_tris(elements_quads)

# create an unstructured triangular grid instance

triangulation = tri.Triangulation(nodes_x, nodes_y, elements_all_tris)

# plot the finite element mesh

plot_fem_mesh(nodes_x, nodes_y, elements)

# plot the contours

plt.tricontourf(triangulation, nodal_values)

# show

plt.colorbar()

plt.axis('equal')

plt.show()

Plot using matplotlib and pandas in pyspark environment

 (.env) boris@boris-All-Series:~/VOTING/PYSPARK$ cat PySparkDataFrame2.py

import pyspark

from pyspark.sql import SparkSession

import matplotlib.pyplot as plt

import pandas as pd

spark = SparkSession.builder.appName('SparkByExamples.com').getOrCreate()

data = [("James","","Smith","36636","M",60000),

        ("Michael","Rose","","40288","M",70000),

        ("Robert","","Williams","42114","",400000),

        ("Maria","Anne","Jones","39192","F",500000),

        ("Jen","Mary","Brown","","F",0)]

columns = ["first_name","middle_name","last_name","dob","gender","salary"]

pysparkDF = spark.createDataFrame(data = data, schema = columns)

pysparkDF.printSchema()

pysparkDF.show(truncate=False)

# Converting dataframe to pandas

pandasDF = pysparkDF.toPandas()

print(pandasDF)

# plotting pandas frames

ax = plt.gca()

pandasDF.plot(kind='line',x='first_name',y='salary',ax=ax,color='red')

pandasDF.plot(kind='bar',x='first_name',y='salary',ax=ax )

plt.show()

(.env) boris@boris-All-Series:~/VOTING/PYSPARK$ cat PySparkDataFrame3.py

import pyspark

from pyspark.sql import SparkSession

import matplotlib.pyplot as plt

import pandas as pd

spark = SparkSession.builder.appName('SparkByExamples.com').getOrCreate()

data = [("James","","Smith",36,"M",60000),

        ("Michael","Rose","",40,"M",70000),

        ("Robert","","Williams",47,"M",400000),

        ("Maria","Anne","Jones",39,"F",500000),

        ("Jen","Mary","Brown",54,"F",250000)]

columns = ["first_name","middle_name","last_name","age","gender","salary"]

pysparkDF = spark.createDataFrame(data = data, schema = columns)

pysparkDF.printSchema()

pysparkDF.show(truncate=False)

# Converting dataframe to pandas

pandasDF = pysparkDF.toPandas()

print(pandasDF)

# plotting pandas frames

pandasDF.loc[:,['salary','age']].plot(secondary_y=['age'], mark_right=False, figsize = (20,5), grid=True)

plt.show()

re — Regular expression operations

 re — Операции с регулярными выражениями

https://docs.python.org/3/library/re.html

Этот модуль обеспечивает операции сопоставления с регулярными выражениями, подобные тем, которые можно найти в Perl.

И шаблоны, и строки для поиска могут быть строками Unicode (str), а также 8-битными строками (bytes). Однако строки Unicode и 8-битные строки нельзя смешивать: то есть вы не можете сопоставлять строку Unicode с шаблоном байтов или наоборот; аналогично, при запросе замены строка замены должна быть того же типа, что и шаблон, и строка поиска.

В регулярных выражениях используется символ обратной косой черты ('\') для обозначения специальных форм или для разрешения использования специальных символов без обращения к их особому значению. Это противоречит тому, что Python использует один и тот же символ для той же цели в строковых литералах; например, чтобы сопоставить литеральную обратную косую черту, может потребоваться написать '\\\\' в качестве строки шаблона, потому что регулярное выражение должно быть \\, а каждая обратная косая черта должна быть выражена как \\ внутри обычного строкового литерала Python. Кроме того, обратите внимание, что любые недопустимые escape-последовательности при использовании Python обратной косой черты в строковых литералах теперь генерируют предупреждение об устаревании, а в будущем это станет SyntaxError. Такое поведение произойдет, даже если это допустимая управляющая последовательность для регулярного выражения.

Решение состоит в том, чтобы использовать нотацию необработанных строк Python для шаблонов регулярных выражений; обратная косая черта не обрабатывается каким-либо особым образом в строковом литерале с префиксом 'r'. Итак, r"\n" — это двухсимвольная строка, содержащая '\' и 'n', а "\n" — односимвольная строка, содержащая новую строку. Обычно шаблоны будут выражены в коде Python с использованием этой записи необработанных строк.

Важно отметить, что большинство операций с регулярными выражениями доступны в виде функций и методов уровня модуля для скомпилированных регулярных выражений. Функции — это ярлыки, которые не требуют от вас предварительной компиляции объекта регулярного выражения, но пропускают некоторые параметры тонкой настройки.

(.env) boris@boris-All-Series:~/VOTING/PCA$ cat extractReCoeff1.py

import re

equations = ["3x+2y+5", "2x-4y+0", "8x+7y-3", "3x+1y-0.5"]

for string_line in equations:

     coeff = re.findall(r'[\d\.\-\+]+', string_line)

     print(coeff)

(.env) boris@boris-All-Series:~/VOTING/PCA$ python3 extractReCoeff1.py

['3', '+2', '+5']

['2', '-4', '+0']

['8', '+7', '-3']

['3', '+1', '-0.5']