Site

http://bit.ly/ufcregis

Links importantes

• Normalization x Standardization (About Feature Scaling and Normalization)
• STAT 479 -- Machine Learning (Fall 2018) - Sebastian Raschka

Datasets

• Pima Indians Diabetes Database (link alternativo no Kaggle)
• UCI Machine Learning Repository
• Kaggle Datasets

Vídeos / Cursos Online

• Vídeos do nosso projeto sobre Ciência de Dados na Prática
  • Minicurso Ciência de Dados na Prática
• In-depth introduction to machine learning in 15 hours of expert videos (EXCELENTE!!!)
• Machine Learning | Coursera (Andrew Ng) (EXCELENTE!!!)
• Curso online gratuito de Machine Learning do Google
• Webinar Udacity - De aprendiz a mestre em Machine Learning com o brasileiro Gilberto Titericz, que foi e tornou a ser o Nº 1 no ranking do Kaggle.

Bibliografia Básica

• JAMES, G., WITTEN, D., HASTIE, T., & TIBSHIRANI, R. (2013). An introduction to statistical learning: with applications in R. Corrected edition. New York: Springer.
• HASTIE, Trevor; TIBSHIRANI, Robert; FRIEDMAN, Jerome. The elements of statistical learning: data mining, inference, and prediction. 2nd ed. New York, NY: Springer, 2009. xxii, 745 p. (Springer series in statistics). ISBN 9780387848570 (enc.).
• RASCHKA, Sebastian; MIRJALILI, Vahid. Python Machine Learning, 2nd Ed. Packt Publishing, 2017. (EXCELENTE!!!)
  • Repositório GitHub do Livro
• BURKOV, Andriy. The Hundred-Page Machine Learning Book. 2019.
• RUSSELL, Stuart J.; NORVIG, Peter. Inteligência artificial. Rio de Janeiro: Elsevier, Campus, 2004. 1021 p. ISBN 8535211772
• BISHOP, Christopher M. Pattern Recognition and Machine Learning. 1 ed. Springer, 2007. ISBN: 0387310738
• THEODORIDIS, Sergios; KOUTROUMBAS, Konstantinos. Pattern recognition. 4 ed. Academic Press, 2008. ISBN 1597492728
• COPPIN, Ben. Inteligência artificial. Rio de Janeiro, RJ: LTC, 2010. xxv 636 p. ISBN 9788521617297
• HAYKIN, Simon S. Redes neurais: princípios e prática. 2. ed. Porto Alegre: Bookman, 2001. xvii, 900 p. ISBN 0132733501 (broch).

Bibliografia Complementar

• MURPHY, Kevin P. Machine Learning: a Probabilistic Perspective. MIT Press, 2012. ISBN 0262018020
• DUDA, Richard O.; HART, Peter E.; STORK, David G. Pattern classification. 2nd. ed. New York: John Wiley, c2001.. xx, 654 p. ISBN 0471056693 (enc.).
• SCHALKOFF, R. Pattern Recognition: Statistical, Structural and Neural Approaches. John Wiley and Sons, 1992. ISBN 9780471529743
• CRISTIANINI, Nello; SHAEW-Taylor. An Introduction to Support Vector Machines and Other Kernel-Based Learning Methods Cambridge University Press, 2000. ISBN-10: 0521780195. ISBN-13: 9780521780193.
• LARSON, Ron; FARBER, Betsy. Estatística aplicada. 4. ed. São Paulo, SP: Pearson Prentice Hall, 2010. xiv,637 p. ISBN 9788576053729 (broch.).
• CORMEN, Thomas H. RIVEST, Ronald L.; LEISERSON, Charles E. Algoritmos: teoria e prática. Rio de Janeiro: Elsevier, 2002. xvii , 916 p. ISBN: 8535209263 (-ed 2012)
• DASGUPTA, Sanjoy; PAPADIMITRIOU, Christos H.; VAZIRANI, Umesh. Algoritmos. São Paulo, SP: McGraw-Hill, 2009. xiv, 320 p.
• HAIR, Joseph F. et al. Análise multivariada de dados. 6. ed. Porto Alegre: Bookman, 2009. 688 p. ISBN 9788577804023 (enc.).
• KLEINBERG, Jon; TARDOS, Éva. Algorithm design. Boston: Pearson/Addison Wesley, c2006. 838 p. :

Listas de Exercícios (a entrega deverá ser realizada pelo SIPPA)

Lista de Exercícios 01 (prazo final para entrega: 12/03/2018 - segunda-feira)

• Crie um Jupyter Notebook e realize os passos a seguir nele:
  1. Carregue os dados do dataset de sobre diabetes a partir do Scikit Learn (veja este Jupyter Notebook).
  2. Mostre em gráficos a correlação entre cada feature (X_i) e o label (y).
     • 2a. Qual feature melhor se ajusta a uma função linear? Por que?
     • 2b. Qual feature pior se ajusta a uma função linear? Por que?
     • Dicas:
       • Gerar para cada feature (atributo) do dataset, um gráfico de dispersão (scatter plot) entre aquela feature (eixo x) e o label (eixo y). E aí observar que gráficos vão se parecer mais (2a) ou menos (2b) com uma linha.
       • Usar manipulação de listas com Python e/ou Numpy.
       • Usar o Matplotlib para gerar gráficos de dispersão (scatter plots).
  3. Mostre em números a correlação entre cada feature (X_i) e o label (y).
     • Dicas:
       • Nessa questão queremos o coeficiente de correlação entre cada feature (atributo) e o label.
       • As planilhas (Excel, Google Sheets, etc.) e bibliotecas Python como Numpy e Pandas já possuem esse cálculo pronto.
  4. Crie um modelo linear usando o Scikit Learn para representar os dados (todo o dataset).
  5. Exiba a fórmula da função linear com todos os seus coeficientes.
  6. Faça predição para todos os dados de entrada (X) usando o modelo criado, ou seja, descubra y_pred.
  7. Avalie o modelo através da métrica MSE. Calcule usando o Scikit Learn e também usando somente o Python ("manualmente").
  8. Crie um novo modelo de regressão linear para a feature que melhor se ajusta a uma função linear (ver questão 2a).
     • Calcule e exiba os coeficientes da função linear de forma manual (usando o Python, mas sem usar o Scikit Learn).
     • Calcule e exiba também os coeficientes da função linear de forma automatizada (usando o Scikit Learn).
     • Mostre um gráfico de dispersão com os pontos da feature e a linha que representa o modelo.
     • Calcule o MSE.
  9. Crie um novo modelo de regressão linear para a feature que pior se ajusta a uma função linear (ver questão 2b).
     • Calcule e exiba os coeficientes da função linear.
     • Mostre um gráfico de dispersão com os pontos da feature e a linha que representa o modelo.
     • Calcule o MSE.

Lista de Exercícios 02 (prazo final para entrega: 19/03/2018 - segunda-feira)

• OBS: Esta Lista sugere o uso de dados e códigos disponíveis no seguinte link. Fique à vontade para usar esses códigos e dados em seu notebook com a resolução desta Lista.
• Crie um Jupyter Notebook e realize os passos a seguir nele:
  • 1. Gere manualmente ("no braço") um dataset (array) com 10 elementos inteiros, tendo como média o valor 3 e como desvio padrão um valor próximo de 2. Desenhe o histograma para os dados gerados.
  • 2. Gere dados randômicos e desenhe o histograma para uma distribuição normal contendo 5000 pontos, que tem como média o valor 60 e como desvio padrão o valor 10.
  • 3. Gere dados randômicos e desenhe o histograma para 2 distribuições escolhidas por você (exceto a dist. normal/gaussiana) a partir da figura a seguir:

• 4. Altere os parâmetros do Gradiente Descendente do notebook 04-Gradiente Descendente.ipynb, para que a diferença entre o valor da métrica de erro do Gradiente Descendente e o valor da métrica de erro da Regressão Linear do Scikit Learn seja menor do que 0.01. Obtenha os coeficientes da regressão linear e o valor do erro. Dica: aumentar muito o número de iterações do Gradiente Descendente.
  • O que ocorre quando você aumenta o valor de learning_rate para 0.01?
  • Que valores de parâmetros podem ser usados com sucesso para obter um valor satisfatório para a métrica de erro ao usar um valor de learning_rate igual a 0.01?
    • Os parâmetros deve ser tais que nenhum warning deve ocorrer durante a execução do gradiente descendente.
• 5. Use o gradiente descendente com boa precisão para:
  • Criar um modelo linear a partir dos seguintes dados:

• linear_model.py
  • classe SimpleLinearRegression
    • Implemente a solução mais simples possível.
    • atributos da classe: b0, b1
    • métodos da classe:
      • fit(X, y)
      • predict(X)
• resample.py
  • split_train_test(n_elem, perc_train, seed)
    • n_elem - número total de elementos (treino + teste).
    • perc_train - percentual dos dados usados para treino.
    • seed - semente para geração de números randômicos.
    • saída (output): array com os índices do dados de treino e array com os índices do dados de teste.
    • Exemplo de entrada: split_train_test(10, 0.7, 0)
      • Saída - 2 arrays com índices dos dados de treino (idx_train) e de teste (idx_test), respectivamente: [2, 8, 4, 9, 1, 6, 7], [3, 0, 5]
    • Dicas:
      • Usar range(n_elem) para criar um array dos índices ordenados.
      • Usar np.random.shuffle(a) para randomizar a ordem dos elementos do array:
        • a = [ i for i in range(10)]
        • np.random.seed(0)
        • np.random.shuffle(a)
1. Crie um Jupyter Notebook e use as bibliotecas criadas na Questão 1 para fazer o que se pede:
   • a) Represente os dados a seguir:

• b) Calcule média, desvio padrão e variância de X.
• c) Divida os dados X, y para 70% de treino e 30% de teste. O resultado deve estar nas variáveis: X_train, y_train, X_test, y_test.
  • Dicas:
    • X_train = X[idx_train], onde idx_train é um array com os índices dos dados de treino.
    • y_train = y[idx_train]
    • X_test = X[idx_test]
    • y_test = y[idx_test]
• d) Crie um modelo de (1) SimpleLinearRegression (sua implementação) e outro modelo usando (2) LinearRegression do Scikit Learn.
• e) Treine os modelos com os dados de treino (X_train, y_train).
• f) Faça as predições para os modelos usando os dados de teste (X_test).
• g) Calcule as métricas MSE, RMSE e MAE para avaliar os modelos criados comparando os rótulos dos dados de teste (y_test) com os dados preditos (y_pred).

Lista de Exercícios 04 (prazo final para entrega: 02/04/2018 - segunda-feira)

• Vamos continuar a implementação de nossas bibliotecas de machine learning na forma mais simples possível usando no Python e o NumPy.
1. Crie os seguintes arquivos com extensão .py e implemente os métodos definidos para cada um deles:
   • transform.py
     • standardize
     • normalize
   • resample.py
     • split_k_fold(n_elem, n_splits=3, shuffle=True, seed=0)
       • n_elem - número total de elementos.
       • n_split - número de folds. Mínimo: 2.
       • shuffle - aleatoriza a ordem dos dados (True) ou não (False).
       • seed - determina uma semente para geração de números aleatórios ou não (None).
       • Retorno: 2 arrays (idx_train e idx_test), cada um com n_splits elementos:
         • um com os índices de treino. Exemplo para n_splits=3, teremos idx_train[0], idx_train[1] e idx_train[2].
         • um com os índices de teste. Exemplo para n_splits=3, teremos idx_test[0], idx_test[1] e idx_test[2].
2. Use sua implementação de split_k_fold a fim de fazer Cross Validation com k=5 (5-Fold) para obter o MSE de regressões para o seguinte dataset sobre a qualidade de vinhos tintos (winequality-red.csv) (para obter detalhes sobre o dataset clique aqui). Compare as seguintes técnicas de regressão (pode usar as implementações do Scikit Learn):
   • SGD - Stochastic Gradient Descent Regressor
   • Linear Regression
   • Linear SVR
   • SVR - Epsilon-Support Vector Regression
   • Random Forest Regressor
   • Gradient Boosting Regressor
3. Faça um gráfico comparativo entre resultados das avaliações (Evaluation) dos modelos acima.
   • Dica: o Notebook do seguinte link pode servir de inspiração.
4. Escolha o melhor algoritmo obtido a partir de cross validation e treine um modelo usando o dataset completo, ou seja, gere um modelo final.
5. Qual a diferença entre Stochastic Gradient Descent e Gradient Descent?

Lista de Exercícios 05 (prazo final para entrega: 09/04/2018 - segunda-feira)

• Vamos continuar a implementação de nossas bibliotecas de machine learning na forma mais simples possível usando no Python e o NumPy.
1. Crie os seguintes arquivos com extensão .py e implemente os métodos definidos para cada um deles:
   • metrics.py - métricas de classificação (ver slides e jupyter notebooks correspondentes). As métricas devem funcionar para classificação binária ou mesmo para múltiplas classes.
     • accuracy
     • precision
     • recall
     • f1_measure
   • linear_model.py
     • Implemente a classe LogisticRegression para realizar classificação binária.
       • Você pode adaptar o exemplo do seguinte link para tomar como base inicial para a sua implementação da regressão logística, que deve ter os métodos fit e predict. Explicação mais detalhada neste outro link.
2. Agora avalie e compare sua implementação de LogisticRegression com a implementação do scikit learn.
   • Use o dataset pima-indians-diabetes.csv em sua avaliação.
   • Divida o dataset em 70% para treino e 30% para teste.
     • Estratifique seus dados, ou seja, garanta que o mesmo percentual de 0s e 1s do dataset completo, ocorra também nos dados de treino e de teste.
       • Exemplo: se no dataset há 40% de 0s e 60% de 1s, esses mesmos percentuais de 0s e 1s devem aparecer nos conjuntos de treino e teste.
       • Crie a função a seguir em resample.py:
         • split_stratified_train_test(y, perc_train, seed)
           • y - labels de cada observação contendo a classe como valor.
           • perc_train - percentual dos dados usados para treino.
           • seed - semente para geração de números randômicos.
           • saída (output): array estratificado com os índices do dados de treino e array estratificado com os índices do dados de teste.
           • Exemplo de entrada: split_stratified_train_test(y, 0.7, 0)
             • Saída - 2 arrays com índices dos dados de treino (idx_train) e de teste (idx_test), respectivamente.
3. Avalie usando suas implementações das métricas: accuracy, precision, recall e f1_measure.
   • Para facilitar seu trabalho, você pode usar a função do sklearn para obter a matriz de confusão.
4. Compare os resultados de suas métricas com os resultados das implementações do scikit learn para as mesmas métricas.
5. Calcule a métrica AUC (Area Under Curve) usando a implementação do sklearn.
   • Dicas:
     • use a função roc_auc_score(y_true, y_score).
     • preste atenção que y_score é diferente de y_pred.
     • Exemplo completo: http://benalexkeen.com/scoring-classifier-models-using-scikit-learn/
     • seria algo assim, usando o modelo de LogisticRegression do próprio sklearn (perceba que a classe possui o método predict_proba):
       • ...
       • y_score = model.predict_proba(X_test)[:,1]
       • fpr, tpr, thresholds = roc_curve(y_test, y_score)
       • ...
6. Desenhe a curva ROC usando a implementação do sklearn.
   • Dicas:
     • Exemplo completo 1: http://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html
     • Exemplo completo 2: http://benalexkeen.com/scoring-classifier-models-using-scikit-learn/

Lista de Exercícios 06 (prazo final para entrega: 16/04/2018 - segunda-feira)

• Vamos continuar a implementação de nossas bibliotecas de machine learning na forma mais simples possível usando no Python e o NumPy.
1. Crie os seguintes arquivos com extensão .py e implemente os métodos definidos para cada um deles:
   • dist_metrics.py - medidas de distância (ver slides correspondentes). Implemente as medidas de distância a seguir:
     • minkowski_distance(X, row, p)
     • euclidean_distance(X, row). Dica: usar minkowski_distance com p=2.
     • manhattan_distance(X, row) Dica: usar minkowski_distance com p=1.
     • chebyshev_distance(X, row)
     • onde X é uma matriz e row é uma linha para calculo da distância entre X e esta linha (row).
     • Veja exemplo de implementação da distância euclidiana neste jupyter notebook.

• knn.py - implementações do knn para classificação e regressão.
  1. Você pode adaptar o exemplo do seguinte link para tomar como base inicial para a sua implementação da regressão logística, que deve ter os métodos fit e predict. Explicação mais detalhada nos slides. No fit você faz o que for possível para melhorar o desempenho de forma genérica antes do predict. Exemplo: não é o caso nesta questão, mas no fit pode-se, por exemplo, contruir uma kd-tree para melhorar o desempenho do kNN na hora do predict. O objetivo do fit é reduzir ao máximo o trabalho do predict.
  2. Implemente as classes de acordo com as seguintes assinaturas:
     • KNNClassifier(k=5, metric='minkowski', p=2)
       • Para detalhes sobre os parâmetros veja esta documentação do sklearn.
     • KNNRegressor(k=5, metric='minkowski', p=2)
       • Para detalhes sobre os parâmetros veja esta documentação do sklearn.
1. Agora avalie e compare sua implementação de KNNClassifier usando a distância euclidiana e a distância manhattan. Compare seus resultados com a implementação do scikit learn somente para a distância euclidiana.
   • Use o dataset winequality-white.csv em sua avaliação. Este dataset pode ser usado para classificação ou regressão. Nesta questão vamos usá-lo para classificação, onde a última coluna é classe.
   • Use o Stratified KFold Cross-Validation do Scikit Learn com k=3. Há um exemplo semelhante de uso neste jupyter notebook.
2. Agora avalie e compare sua implementação de KNNRegressor usando a distância euclidiana e a distância manhattan. Compare seus resultados com a implementação do scikit learn somente para a distância euclidiana.
   • Use o dataset winequality-white.csv em sua avaliação. Este dataset pode ser usado para classificação ou regressão. Nesta questão vamos usá-lo para classificação, onde a última coluna é um valor que indica a qualidade do vinho.
   • Use o KFold Cross-Validation do Scikit Learn com k=5. Há um exemplo semelhante de uso neste jupyter notebook. Você deve usar o KFold e não o StratifiedKFold usado no exemplo.

Lista de Exercícios 07 (prazo final para entrega: 22/04/2018 - DOMINGO)

• Use K-Fold Cross Validation com k = 5 para resolver os seguintes problemas de machine learning:
  • Regressão
    • Dataset: boston house-prices dataset
    • Aplicar Standardization nas features.
    • Comparar os resultados dos seguintes algoritmos: Gradient Descent, Linear Regression, kNN, SVM.
    • Usar as seguintes métricas: RMSE, MAE.
    • Escolher a melhor técnica e criar um modelo final usando todo o dataset para treinar o modelo.
  • Classificação
    • Dataset: breast cancer wisconsin dataset
    • Aplicar Normalization nas features.
    • Comparar os resultados dos seguintes algoritmos: Logistic Regression, kNN, Naive Bayes, SVM.
    • Mostrar a matriz de confusão.
    • Usar as seguintes métricas: Accuracy, Precision, Recall, F1-Measure, AUC (Area Under the Curve).
    • Plotar curva ROC dos diferentes algoritmos.
    • Escolher a melhor técnica e criar um modelo final usando todo o dataset para treinar o modelo.
  • Você pode usar as implementações do Scikit Learn.
  • Preencha seus resultados de RMSE (para o problema de regressão) e Accuracy (para o problema de classificação) na seguinte planilha online.
    • Nossa primeira competiçãozinha interna!!!
    • Tentem melhorar os resultados.

Lista de Exercícios 08 (prazo final para entrega: 07/05/2018 - Segunda)

• Adicione à sua biblioteca Python as seguintes implementações. Tome por base as implementações que fornecemos já prontas nos Jupyter Notebooks da disciplina e que estão nos links entre parênteses a seguir (tarefa simples: é só copiar, colar e usar as classes em sua biblioteca Python).
  • Perceptron (Jupyter Notebook com exemplo de uso)
  • Adaline com Gradiente Descendente Batch (Jupyter Notebook com exemplo de uso)
  • Adaline com Gradiente Descendente Estocástico (Jupyter Notebook com exemplo de uso)
• Desenhe o gráfico de região de decisão (plot_decision_regions) de cada um dos 3 algoritmos acima para os dados do dataset pima-indians-diabetes.csv.
  • Veja exemplos de gráficos de região de decisão nos Jupyter Notebooks mencionados acima.
  • Como o gráfico está limitado a 2 dimensões, sugiro a escolha das 2 features com maior correlação com o label (target).
    • Use os dados das features standardizados.
• Use K-Fold Cross Validation Estratificada com k = 3 para obter a acurácia dos 3 algoritmos acima sobre o dataset pima-indians-diabetes.csv. Faça Standardization dos dados (fit para o conjunto de treino e transform para treino e teste).
  • Compare também com as implementações de Logistic Regression, kNN, Naive Bayes e SVM do Scikit-Learn.
  • Ajuste os algoritmos através de seus hiper-parâmetros para obter os melhores resultados possíveis em cada algoritmo.
• Explique as diferenças entre o Adaline com Gradiente Descendente em Batch e o Adaline com Gradiente Descendente Estocástico.

Lista de Exercícios 09 (prazo final para entrega: 14/05/2018 - Segunda)

• O dataset de renda de americanos dos Estados Unidos tem como rótulo se a pessoa ganha ou não mais de 50.000 dólares por ano.
• O dataset contém dados categóricos e valores faltando.
• Faça o melhor pre-processamento possível para tornar tal dataset adequado para uso em diversos algoritmos de aprendizagem de máquina.
  • Faça atribuição da média da coluna para valores faltantes, caso o percentual de valores faltantes da coluna não seja muito grande.
  • Transforme categorias usadas nas features e label em números. Categorias que não possuem uma ordem implícita devem ser transformadas em features binárias.
• Use 5-Fold Cross Validation Estratificada para obter a Accuracy através do uso dos seguintes algoritmos: Logistic Regression, kNN, Naive Bayes, SVM.
  • Faça Standardization dos dados (fit para o conjunto de treino e transform para treino e teste).
• Escolha a melhor técnica e crie um modelo final usando todo o dataset para treinar o modelo.

Lista de Exercícios 10 (prazo final para entrega: 21/05/2018 - Segunda)

• Use o dataset do link a seguir para aplicar sobre ele o gradiente descendente estocástico.
  • O label (target) do dataset é o atributo admit.
  • Use 70% do dados para treino e 30% para teste sem validação cruzada, mas com estratificação.
• Obtenha e compare os coeficientes (coef_ e intercept_) usando modelos com diferentes penalidades / regularizações:
  • Sem Regularização
  • Com Reguralização L1
  • Com Regularização L2
  • Com Regularização Elastic Net
• Para os experimentos com Regularização, crie também modelos variando a força da regularização (alpha). Use alpha com os seguintes valores: 0.0001, 0.01, 1, 10, 100.
• Compare a acurácia dos modelos criados.

Lista de Exercícios 11 (prazo final para entrega: 04/06/2018 - Segunda)

• Complemente a Lista de Exercícios 7 para também avaliar o desempenho dos algoritmos DecisionTree, RandomForest e Gradient Boosting tanto no problema de regressão (DecisionTreeRegressor, RandomForestRegressor e GradientBoostingRegressor), como também no problema de classificação (DecisionTreeClassifier, RandomForestClassifier e GradientBoostingClassifier).
  • Use um valor constante para o parâmetro random_state e teste os resultados com as seguintes combinações de hiper-parâmetros para RandomForest e Gradient Boosting:
    • learning_rate: 0.1, 0.05, 0.01 (somente para o Gradient Boosting)
    • n_estimators: 50, 100, 200
    • max_depth: 3, 5, 7
  • Mostre a importância das features de acordo com o melhor modelo de classificação e o melhor modelo de regressão encontrados dentre os 3 usados nesta lista de exercícios (DecisionTree, RandomForest e Gradient Boosting).

Lista de Exercícios 12 (prazo final para entrega: 11/06/2018 - Segunda)

• Faça a clusterização do dataset deste link usando o algoritmo k-means++.
  • O dataset possui os seguintes dados de motoristas: a distância média dirigida por dia e a média percentual do tempo que um motorista estava 5mph acima do limite de velocidade.
  • Portanto, agrupe os motoristas pela similaridade das features acima usando o algoritmo k-means++.
• Use o método do cotovelo (Elbow Method) e a análise de silhueta (Silhouette Analysis) para identificar o melhor valor de k.
  • Mostre ambos graficamente.
  • Na análise de silhueta, para o melhor valor encontrado para k, mostre: k-1, k e k+1.
• Para o mesmo valor de k obtido acima, execute o k-means original com inicialização totalmente randômica.
  • Compare os resultados de k-means e k-means++ (1) graficamente, (2) tempo de execução e (3) número mínimo de iterações necessárias para chegar ao melhor resultado.

Lista de Exercícios 13 (prazo final para entrega: 17/06/2018 - Domingo)

• Revisão para a Prova:
  • Refazer a Lista 7 + Lista 11 (Somente para estudo, assim não precisa entregar novamente)
  • Responder os itens a seguir desta mesma lista de exercícios.
• Use o dataset da Lista 12 para:
  1. Fazer clusterização hierárquica (HC) usando os seguintes métodos e mostrando os dendrogramas para:
     • Single
     • Complete
     • Average
  2. Escolher uma clusterização hierárquica do item 1 e, a partir dela, escolher uma linha de corte e mostrar os clusters no gráfico.
  3. Fazer clusterização DBSCAN com diferentes valores de eps e minPoints.
  4. Escolher um resultado do item 3 e, a partir dele, mostrar os clusters no gráfico.
• Questões conceituais:
  1. Quais as diferenças entre feature selection e feature extraction?
  2. Dê exemplos de técnicas usadas para feature selection.
  3. Dê exemplos de técnicas usadas para feature extraction.
• Use o iris dataset e a partir dele:
  1. Reduza a dimensionalidade para 2 dimensões usando PCA, e mostre os pontos em um gráfico, onde cada classe é visualizada com uma cor diferente.
  2. Reduza a dimensionalidade para 2 dimensões usando LDA, e mostre os pontos em um gráfico, onde cada classe é visualizada com uma cor diferente.