<jupyter_start><jupyter_text>IntroduçãoBaseado no trabalho do professor [<NAME>](https://github.com/thsant/sklearn-intro).Há um conjunto de técnicas de **aprendizado** e **inferência** muito grande. Alguns exemplos:* Regressão Linear* Regressão Logística* Clustering (diversos algoritmos)* Máquinas de suporte vetorial* Processos Gaussianos* PCA/LDATais técnicas apresentam nomes diferentes em comunidades diferentes:* Cientistas da Computação e engenheiros chamam de **aprendizado de máquina*** Economistas chamam de **econometria*** Estatísticos de **aprendizado estatístico de padrões*** Bioinformatas de **bioestatística**  Qual é a tarefa em questão?Essas técnicas tentam resolver um **problema de aprendizado**: dadas **n amostras** de dados, **predizer** as propriedades de dados não observados.Problemas de aprendizado são geralmente dividos em 2 casos:**Aprendizado supervisionado** - no qual as amostras apresentam informação extra sobre a propriedade a ser prevista.* Classificação: a propriedade a ser prevista é uma classe/categoria    * *Exemplo*: classificar *e-mail* como SPAM/HAM a partir de seu conteúdo* Regressão: a propriedade a ser prevista é um valor contínuo    * *Exemplo*: o *preço* de uma casa a partir de dados de localização, cômodos, vizinhança, etc.**Aprendizado não-supervisionado** - no qual as amostras não apresentam informação extra, ou seja, desejamos buscar alguma **estrutura** nesses dados (aglomerar dados semelhantes e/ou determinar a distribuição de probabilidade que gerou tais dados)  Visão geral da Sklearn[Visão geral](http://scikit-learn.org/stable/tutorial/machine_learning_map/index.html).![ML map](http://scikit-learn.org/stable/_static/ml_map.png)  DADOS<jupyter_code>from sklearn.datasets import make_blobs, load_boston
import matplotlib.pyplot as plt
X, y = make_blobs(n_samples=1000, centers=20, random_state=123)
labels = ["b", "r"]
y = np.take(labels, (y < 10))
print(X) 
print(y[:5])
# X is a 2 dimensional array, with 1000 rows and 2 columns
print(X.shape)
 
# y is a vector of 1000 elements
print(y.shape)
# Rows and columns can be accessed with lists, slices or masks
print(X[[1, 2, 3]])     # rows 1, 2 and 3
print(X[:5])            # 5 first rows
print(X[500:510, 0])    # values from row 500 to row 510 at column 0
print(X[y == "b"][:5])  # 5 first rows for which y is "b"
# Plot
plt.figure()
for label in labels:
    mask = (y == label)
    plt.scatter(X[mask, 0], X[mask, 1], c=label)
plt.xlim(-10, 10)
plt.ylim(-10, 10)
plt.show()<jupyter_output><empty_output><jupyter_text>Datasets<jupyter_code>boston = load_boston()
plt.scatter(boston.data[:,5], boston.target)
plt.xlabel(u'RM (número médio de cômodos)')
plt.ylabel(u'Valor médio (em US$ 1.000)')
plt.title('Boston House Prices dataset')<jupyter_output><empty_output><jupyter_text>API únicaTodos os algoritmos de aprendizado do scikit-learn compartilham uma API uniforme e limitada que consiste em interfaces complementares:* uma interface **estimator** para modelos de construção e montagem;* uma interface **predictor** para fazer previsões;* uma interface **transformer** para converter dados.O objetivo é aplicar uma API simples e consistente para tornar trivial trocar ou conectar algoritmos. Fit/Predict- No Sklearn, os algoritmos são representados por objetos (POO)- Tais objetos implementam a **interface fit/predict**- `fit`    - realiza a etapa de **aprendizado**- `predict`    - realiza as etapas de **regressão** ou **classificação**- O **modelo** aprendido pode ser armazenado em disco utilizando o módulo de persistência `pickle` Estimator<jupyter_code># Exemplo de estimador
class Estimator(object):
    def fit(self, X, y=None):
        """Fits estimator to data."""
        # set state of ``self``
        return self
# Import the nearest neighbor class
from sklearn.neighbors import KNeighborsClassifier  # Change this to try 
                                                    # something else

# Set hyper-parameters, for controlling algorithm
clf = KNeighborsClassifier(n_neighbors=5)

# Learn a model from training data
clf.fit(X, y)<jupyter_output><empty_output><jupyter_text>Predictors<jupyter_code># Make predictions  
print(clf.predict(X[:5]))
# Compute (approximate) class probabilities
print(clf.predict_proba(X[:5]))
from tutorial import plot_surface    
plot_surface(clf, X, y)
from tutorial import plot_histogram    
plot_histogram(clf, X, y)<jupyter_output><empty_output><jupyter_text>Classifier zoo Decision TreeÁrvores de decisão são modelos estatísticos que utilizam um treinamento supervisionado para a classificação e previsão de dados. Em outras palavras, em sua construção é utilizado um conjunto de treinamento formado por entradas e saídas. Estas últimas são as classes.![Arvore](https://web.tecnico.ulisboa.pt/ana.freitas/bioinformatics.ath.cx/bioinformatics.ath.cx/uploads/RTEmagicC_arv_dec3.gif.gif)[Documentação](http://scikit-learn.org/stable/modules/tree.html)[Tutorial](http://www.r2d3.us/uma-introducao-visual-ao-aprendizado-de-maquina-1/)Por exemplo, no exemplo abaixo, as árvores de decisão aprendem com dados para aproximar uma curva de seno com um conjunto de regras de decisão if-then-else. Quanto mais profunda for a árvore, mais complexa será a decisão e mais ajustada ao modelo.![](https://raw.githubusercontent.com/data-science-joinville/notebooks/b8c3bc2a6268cd003956abd6bd61a841a003a42a/notebooks/titanic/docs/decision-tree-examplee.png)[Referência](https://sebastianraschka.com/faq/docs/bagging-boosting-rf.html)<jupyter_code>from tutorial import plot_clf
from sklearn.tree import DecisionTreeClassifier 
clf = DecisionTreeClassifier()
clf.fit(X, y)
plot_clf(clf, X, y)<jupyter_output><empty_output><jupyter_text>Random ForestConstruir várias árvores de decisão e tirar a média das suas decisões.<jupyter_code>from sklearn.ensemble import RandomForestClassifier 
clf = RandomForestClassifier(n_estimators=500)
# from sklearn.ensemble import ExtraTreesClassifier 
# clf = ExtraTreesClassifier(n_estimators=500)
clf.fit(X, y)
plot_clf(clf, X, y)<jupyter_output><empty_output><jupyter_text>Logistic Regression [Documentação](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html)[Tutorial](http://ufldl.stanford.edu/tutorial/supervised/LogisticRegression/)[Logistic Function](https://www.wikiwand.com/en/Logistic_function)No regressor logístico tenta-se prever a probabilidade de um dado exemplo pertencer a classe de sobreviventes versos a probabilidade de percenter a classe de falecidos.$f(x) = \frac{L}{1 + \mathrm e^{-k(x-x_0)}}$![](https://raw.githubusercontent.com/data-science-joinville/notebooks/b8c3bc2a6268cd003956abd6bd61a841a003a42a/notebooks/titanic/docs/logistic-curve.png)Para a curva padrão$L=1,k=1,x_0=0$ Um exemplo![](https://raw.githubusercontent.com/data-science-joinville/notebooks/b8c3bc2a6268cd003956abd6bd61a841a003a42a/notebooks/titanic/docs/logistic-regression-example.jpg)[Referência](https://www.mssqltips.com/sqlservertip/3471/introduction-to-the-sql-server-analysis-services-logistic-regression-data-mining-algorithm/)<jupyter_code>from sklearn.linear_model import LogisticRegression
clf = LogisticRegression()
clf.fit(X, y)
plot_clf(clf, X, y)<jupyter_output><empty_output><jupyter_text>Support Vector Machine (SVM)[Documentação](http://scikit-learn.org/stable/modules/svm.html)Usa um subconjunto de pontos de treinamento na função de decisão (chamados vetores de suporte), portanto é eficiente na memória.![](https://raw.githubusercontent.com/data-science-joinville/notebooks/b8c3bc2a6268cd003956abd6bd61a841a003a42a/notebooks/titanic/docs/svm-example.jpg)[Referência](http://www-personal.umich.edu/~johnhugo/commercial/inc/img/SVM.jpg)<jupyter_code>from sklearn.svm import SVC
clf = SVC(kernel="linear")  # try kernel="rbf" instead
clf.fit(X, y)
plot_clf(clf, X, y)<jupyter_output><empty_output><jupyter_text>Multilayer PerceptronÉ uma rede neural semelhante à perceptron, mas com mais de uma camada de neurônios em alimentação direta. Tal tipo de rede é composta por camadas de neurônios ligadas entre si por sinapses com pesos. O aprendizado nesse tipo de rede é geralmente feito através do algoritmo de retro-propagação do erro. ![](https://camo.githubusercontent.com/d95fb90b396fc77c614cc6b176dd049066273f96/68747470733a2f2f7777772e64726f70626f782e636f6d2f732f717334746f6a763575356834386c662f6d756c74696c617965725f70657263657074726f6e2e706e673f7261773d31)<jupyter_code>from sklearn.neural_network import MLPClassifier
clf = MLPClassifier(hidden_layer_sizes=(100, 100, 100), activation="relu", learning_rate="invscaling")
clf.fit(X, y)
plot_clf(clf, X, y)<jupyter_output><empty_output><jupyter_text>Aprendizado supervisionado no Sklearn- Nearest Neighbors- Support Vector Machines (SVM)    - Linear Support    - Radial Basis Function (RGB) kernel SVM- Decision Trees- Ensemble    - Random Forests    - AdaBoost- Linear Discriminant Analysis- Gaussian Processes<jupyter_code>import sklearn
sklearn.__version__
print(__doc__)


# Code source: <NAME>
#              <NAME>
# Modified for documentation by <NAME>
# License: BSD 3 clause

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis as QDA

def classifier_showroom(names, classifiers):
    h = .02  # step size in the mesh

    X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
                           random_state=1, n_clusters_per_class=1)
    rng = np.random.RandomState(2)
    X += 2 * rng.uniform(size=X.shape)
    linearly_separable = (X, y)

    datasets = [make_moons(noise=0.3, random_state=0),
                make_circles(noise=0.2, factor=0.5, random_state=1),
                linearly_separable
                ]

    figure = plt.figure(figsize=(12, 8))
    i = 1
    # iterate over datasets
    for ds in datasets:
        # preprocess dataset, split into training and test part
        X, y = ds
        X = StandardScaler().fit_transform(X)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)

        x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
        y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
        xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                             np.arange(y_min, y_max, h))

        # just plot the dataset first
        cm = plt.cm.RdBu
        cm_bright = ListedColormap(['#FF0000', '#0000FF'])
        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
        # Plot the training points
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
        # and testing points
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
        ax.set_xlim(xx.min(), xx.max())
        ax.set_ylim(yy.min(), yy.max())
        ax.set_xticks(())
        ax.set_yticks(())
        i += 1

        # iterate over classifiers
        for name, clf in zip(names, classifiers):
            ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
            clf.fit(X_train, y_train)
            score = clf.score(X_test, y_test)

            # Plot the decision boundary. For that, we will assign a color to each
            # point in the mesh [x_min, m_max]x[y_min, y_max].
            if hasattr(clf, "decision_function"):
                Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
            else:
                Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]

            # Put the result into a color plot
            Z = Z.reshape(xx.shape)
            ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)

            # Plot also the training points
            ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
            # and testing points
            ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
                       alpha=0.6)

            ax.set_xlim(xx.min(), xx.max())
            ax.set_ylim(yy.min(), yy.max())
            ax.set_xticks(())
            ax.set_yticks(())
            ax.set_title(name)
            ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
                    size=15, horizontalalignment='right')
            i += 1

    figure.subplots_adjust(left=.02, right=.98)
names = ["Nearest Neighbors", "Linear SVM", "RBF SVM"]
classifiers = [
    KNeighborsClassifier(3),
    SVC(kernel="linear", C=0.025),
    SVC(gamma=2, C=1)]

classifier_showroom(names, classifiers)
names = ["Decision Tree", "Random Forest", "AdaBoost"]
classifiers = [
    DecisionTreeClassifier(max_depth=5),
    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
    AdaBoostClassifier()]
classifier_showroom(names, classifiers)
names = ["Naive Bayes", "LDA", "QDA"]
classifiers = [
    GaussianNB(),
    LDA(),
    QDA()]

classifier_showroom(names, classifiers)<jupyter_output><empty_output><jupyter_text>Aprendizado não-supervisionado no Sklearn- Gaussian mixture models- Clustering    - Affinity propagation    - Mean-shift    - Spectral clustering    - Hierarchical clustering    - DBSCAN- Neural Networks (unsupervised)    - Restricted Boltzmann machines<jupyter_code>def clustering_showroom():

    import time

    import numpy as np
    import matplotlib.pyplot as plt

    from sklearn import cluster, datasets
    from sklearn.metrics import euclidean_distances
    from sklearn.neighbors import kneighbors_graph
    from sklearn.preprocessing import StandardScaler

    np.random.seed(0)

    # Generate datasets. We choose the size big enough to see the scalability
    # of the algorithms, but not too big to avoid too long running times
    n_samples = 1500
    noisy_circles = datasets.make_circles(n_samples=n_samples, factor=.5,
                                          noise=.05)
    noisy_moons = datasets.make_moons(n_samples=n_samples, noise=.05)
    blobs = datasets.make_blobs(n_samples=n_samples, random_state=8)
    no_structure = np.random.rand(n_samples, 2), None

    colors = np.array([x for x in 'bgrcmykbgrcmykbgrcmykbgrcmyk'])
    colors = np.hstack([colors] * 20)

    plt.figure(figsize=(17, 9.5))
    plt.subplots_adjust(left=.001, right=.999, bottom=.001, top=.96, wspace=.05,
                        hspace=.01)

    plot_num = 1
    for i_dataset, dataset in enumerate([noisy_circles, noisy_moons, blobs,
                                         no_structure]):
        X, y = dataset
        # normalize dataset for easier parameter selection
        X = StandardScaler().fit_transform(X)

        # estimate bandwidth for mean shift
        bandwidth = cluster.estimate_bandwidth(X, quantile=0.3)

        # connectivity matrix for structured Ward
        connectivity = kneighbors_graph(X, n_neighbors=10)
        # make connectivity symmetric
        connectivity = 0.5 * (connectivity + connectivity.T)

        # Compute distances
        #distances = np.exp(-euclidean_distances(X))
        distances = euclidean_distances(X)

        # create clustering estimators
        ms = cluster.MeanShift(bandwidth=bandwidth, bin_seeding=True)
        two_means = cluster.MiniBatchKMeans(n_clusters=2)
        ward = cluster.AgglomerativeClustering(n_clusters=2,
                        linkage='ward', connectivity=connectivity)
        spectral = cluster.SpectralClustering(n_clusters=2,
                                              eigen_solver='arpack',
                                              affinity="nearest_neighbors")
        dbscan = cluster.DBSCAN(eps=.2)
        affinity_propagation = cluster.AffinityPropagation(damping=.9,
                                                           preference=-200)

        average_linkage = cluster.AgglomerativeClustering(linkage="average",
                                affinity="cityblock", n_clusters=2,
                                connectivity=connectivity)

        for name, algorithm in [
                                ('MiniBatchKMeans', two_means),
                                ('AffinityPropagation', affinity_propagation),
                                ('MeanShift', ms),
                                ('SpectralClustering', spectral),
                                ('Ward', ward),
                                ('AgglomerativeClustering', average_linkage),
                                ('DBSCAN', dbscan)
                               ]:
            # predict cluster memberships
            t0 = time.time()
            algorithm.fit(X)
            t1 = time.time()
            if hasattr(algorithm, 'labels_'):
                y_pred = algorithm.labels_.astype(np.int)
            else:
                y_pred = algorithm.predict(X)

            # plot
            plt.subplot(4, 7, plot_num)
            if i_dataset == 0:
                plt.title(name, size=18)
            plt.scatter(X[:, 0], X[:, 1], color=colors[y_pred].tolist(), s=10)

            if hasattr(algorithm, 'cluster_centers_'):
                centers = algorithm.cluster_centers_
                center_colors = colors[:len(centers)]
                plt.scatter(centers[:, 0], centers[:, 1], s=100, c=center_colors)
            plt.xlim(-2, 2)
            plt.ylim(-2, 2)
            plt.xticks(())
            plt.yticks(())
            plt.text(.99, .01, ('%.2fs' % (t1 - t0)).lstrip('0'),
                     transform=plt.gca().transAxes, size=15,
                     horizontalalignment='right')
            plot_num += 1

    plt.show()
clustering_showroom()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10647633859142412, 'fraction_numerical': 0.0276049766718507, 'mean_word_length': 3.361676356589147, 'pattern_counts': {'":': 0, '<': 50, '<?xml version=': 0, '>': 49, 'https://': 10, 'lorem ipsum': 0, 'www.': 4, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 12, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '11', 'dir': 'jupyter-structured-clean-dedup', 'id': '151217', 'license': 'MIT', 'n_tokens_mistral': 6370, 'n_tokens_neox': 5873, 'n_words': 1397, 'path': 'machine-learning/introducao.ipynb', 'repo_name': 'magrathealabs/university', 'size': '18035'}