<jupyter_start><jupyter_text>Na medida do possível anonimizei a empresa e as questões.  Teste de Programação<jupyter_code>import numpy as np
import pandas as pd
from matplotlib import pyplot as plt<jupyter_output><empty_output><jupyter_text>Questão 1 Como é construído o dendograma? Como checo a qualidade do agrupamento? Como funcionam os métodos de agrupamento hierárquico?<jupyter_code>from scipy.cluster.hierarchy import dendrogram, linkage
from sklearn.metrics import silhouette_samples
from sklearn.metrics import silhouette_score
df12 = pd.read_csv('./agrup.csv', sep=';', header=None)
df12 = df12.to_numpy().astype(float)
y = [2, 8, 9, 7, 7, 8, 11, 11, 6, 5]
linked = linkage(y, 'single')

plt.figure(figsize=(5, 3))
dendrogram(linked,
            orientation='top',
            labels=range(1, 6),
            distance_sort='descending',
            show_leaf_counts=True)
plt.show()
silhouette_score(df12.astype(float), [0, 0, 1, 1, 1], metric='precomputed')
silhouette_samples(df12.astype(float), [0, 0, 1, 1, 1], metric='precomputed')<jupyter_output><empty_output><jupyter_text>Questão 2 Como funciona o DBSCAN?<jupyter_code>from sklearn.cluster import DBSCAN
dbscan = DBSCAN(eps=6, min_samples=3, metric='precomputed')
dbscan.fit(df12)
dbscan.labels_<jupyter_output><empty_output><jupyter_text>Questão 3 Como funciona o kNN? Qual a complexidade computacional do kNN? O tipo de validação cruzada interfere na complexidade?<jupyter_code>from sklearn.neighbors import KNeighborsClassifier
df34 = pd.read_csv('./class.csv', sep=';')
def distance_matrix(X0, X1=None):
  if X1 is None:
    X1 = X0
  X = np.zeros((X1.shape[0], X0.shape[0]))
  for i in range(X0.shape[0]):
    for j in range(X1.shape[0]):
      d = 0
      for k in range(X0.shape[1]):
        d += 0 if X0.iloc[i, k] == X1.iloc[j, k] else 1
      X[j, i] = d
  return X
X = distance_matrix(df34.iloc[:, :-1])
y = [0] * 6 + [1] * 6
clf = KNeighborsClassifier(n_neighbors=3, metric='precomputed')
clf.fit(X, y).predict(X)
row = pd.DataFrame.from_dict({
  'SextaSabado': ['Sim'], 
  'Faminto': ['Sim'],
  'Clientes': ['Alguns'], 
  'Tipo': ['Italiano']})
row_dist = distance_matrix(df34.iloc[:, :-1], row)
clf.predict(row_dist)<jupyter_output><empty_output><jupyter_text>Questão 4 Como interpretar precisão, revocação e F1? Que métrica utilizar caso o erro de cada classe seja diferente?<jupyter_code>from sklearn.metrics import classification_report
df34_par = df34.loc[[0, 2, 4, 6, 8, 10]]
df34_impar = df34.loc[[1, 3, 5, 7, 9, 11]]
X_par = distance_matrix(df34_par.iloc[:, :-1])
X_impar = distance_matrix(df34_par.iloc[:, :-1], df34_impar.iloc[:, :-1])
knn2 = KNeighborsClassifier(n_neighbors=3, metric='precomputed')
knn2.fit(X_par, [0, 0, 0, 1, 1, 1]).predict(X_par)
knn2.predict(X_impar)
print(classification_report([0, 0, 0, 1, 1, 1], knn2.predict(X_impar)))<jupyter_output><empty_output><jupyter_text>Questão 5 Como funciona o lasso? Como funciona a regressão linear? O que significa uma variável ter coeficiente zero?<jupyter_code>from sklearn.linear_model import Lasso
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import GridSearchCV
df56 = pd.read_csv('regre.csv', sep=';')
df56 = df56.to_numpy()

x = df56[:, :-1]
y = df56[:, -1].reshape(-1, 1)
reg = GridSearchCV(Lasso(), 
                    param_grid={
                      'alpha': [10 ** x for x in range(-3, 4)]}, 
                    scoring='neg_mean_absolute_error',
                    cv=LeaveOneOut())
reg.fit(x, y)

print(f'melhor hiperparametro: {reg.best_params_}')
print('mae:', np.mean(np.abs(reg.predict(x) - y)))
reg0 = LinearRegression()
reg0.fit(x, y)

print(f'mae: {mean_absolute_error(y, reg0.predict(x))}')<jupyter_output><empty_output><jupyter_text>Questão 6 Como funciona o algoritmo CART? Como funciona o bootstraping?<jupyter_code>from sklearn.tree import DecisionTreeRegressor
from sklearn.tree import plot_tree
reg = DecisionTreeRegressor(max_depth=3)
reg.fit(x, y)
reg.predict([[245, 4, 9700, 4600, 1835]])
reg.decision_path([[245, 4, 9700, 4600, 1835]]).A
plot_tree(reg);<jupyter_output><empty_output><jupyter_text>Questão 7 Perguntas sobre SQL, em particular ORDER BY, GROUP BY e CREATE INDEX.  Questão 8 Perguntas sobre recursão e complexidade de algoritmos.<jupyter_code>def calculo(x, y):
  if y == 0:
    return 0
  elif y == 1:
    return x
  else:
    return x + calculo(x, y - 1)

print('calculo(5, 4):', calculo(5, 4))
print('A soma tem complexidade O(y)?')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1389070324406706, 'fraction_numerical': 0.041802743305029394, 'mean_word_length': 5.076719576719577, 'pattern_counts': {'":': 0, '<': 33, '<?xml version=': 0, '>': 33, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '649573', 'license': 'MIT', 'n_tokens_mistral': 1912, 'n_tokens_neox': 1765, 'n_words': 426, 'path': 'misc/2021.01.21/test.ipynb', 'repo_name': 'vncsna/random', 'size': '4593'}