I am working on the file "2019-07-10-CICM/notebooks/bqplot.ipynb".
The first task is:
Moving points around
Can you write Python code for it?

from bqplot import *

size = 100
np.random.seed(0)
x_data = range(size)
y_data = np.cumsum(np.random.randn(size) * 100.0)

## Enabling moving of points in scatter. Try to click and drag any of the points in the scatter and
## notice the line representing the mean of the data update

sc_x = LinearScale()
sc_y = LinearScale()

scat = Scatter(x=x_data[:10], y=y_data[:10], scales={'x': sc_x, 'y': sc_y}, default_colors=['blue'],
               enable_move=True)
lin = Lines(scales={'x': sc_x, 'y': sc_y}, stroke_width=4, line_style='dashed', colors=['orange'])
m = Label(value='Mean is %s'%np.mean(scat.y))

def update_line(change):
    with lin.hold_sync():
        lin.x = [np.min(scat.x), np.max(scat.x)]
        lin.y = [np.mean(scat.y), np.mean(scat.y)]
        m.value='Mean is %s'%np.mean(scat.y)

update_line(None)

# update line on change of x or y of scatter
scat.observe(update_line, names='x')
scat.observe(update_line, names='y')

ax_x = Axis(scale=sc_x)
ax_y = Axis(scale=sc_y, tick_format='0.2f', orientation='vertical')

fig = Figure(marks=[scat, lin], axes=[ax_x, ax_y])

## In this case on drag, the line updates as you move the points.
with scat.hold_sync():
    scat.enable_move = True
    scat.update_on_move = True
    scat.enable_add = False

display(m, fig)


I am working on the file "2019-07-10-CICM/notebooks/bqplot.ipynb".
The first task is:
Selections
Can you write Python code for it?

def interval_change_callback(change):
    db.value = str(change['new'])

intsel = bq.interacts.FastIntervalSelector(scale=xs, marks=[line])
intsel.observe(interval_change_callback, names=['selected'] )

db = widgets.Label()
db.value = str(intsel.selected)
display(db)

fig = bq.Figure(marks=[line], axes=[xax, yax], animation_duration=1000, interaction=intsel)
display(fig)

line.selected


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
Add an animation button
Can you write Python code for it?

play_button = Play(min=1800, max=2008, interval=time_interval)
jslink((play_button, 'value'), (year_slider, 'value'))


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
Cleaning and Formatting JSON Data
Can you write Python code for it?

data = pd.read_json(os.path.abspath('./nations.json'))

def clean_data(data):
    for column in ['income', 'lifeExpectancy', 'population']:
        data = data.drop(data[data[column].apply(len) <= 4].index)
    return data

def extrap_interp(data):
    data = np.array(data)
    x_range = np.arange(1800, 2009, 1.)
    y_range = np.interp(x_range, data[:, 0], data[:, 1])
    return y_range

def extrap_data(data):
    for column in ['income', 'lifeExpectancy', 'population']:
        data[column] = data[column].apply(extrap_interp)
    return data

data = clean_data(data)
data = extrap_data(data)

income_min, income_max = np.min(data['income'].apply(np.min)), np.max(data['income'].apply(np.max))
life_exp_min, life_exp_max = np.min(data['lifeExpectancy'].apply(np.min)), np.max(data['lifeExpectancy'].apply(np.max))
pop_min, pop_max = np.min(data['population'].apply(np.min)), np.max(data['population'].apply(np.max))

def get_data(year):
    year_index = year - 1800
    income = data['income'].apply(lambda x: x[year_index])
    life_exp = data['lifeExpectancy'].apply(lambda x: x[year_index])
    pop =  data['population'].apply(lambda x: x[year_index])
    return income, life_exp, pop


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
Creating the Scatter Mark with the appropriate size and color parameters passed
To generate the appropriate graph, we need to pass the population of the country to the size attribute and its region to the color attribute.
Can you write Python code for it?

# Start with the first year's data
cap_income, life_exp, pop = get_data(initial_year)

wealth_scat = Scatter(x=cap_income, y=life_exp, color=data['region'], size=pop,
                      names=data['name'], display_names=False,
                      scales={'x': x_sc, 'y': y_sc, 'color': c_sc, 'size': size_sc},
                      default_size=4112, tooltip=tt, animate=True, stroke='Black',
                      unhovered_style={'opacity': 0.5})

nation_line = Lines(x=data['income'][0], y=data['lifeExpectancy'][0], colors=['Gray'],
                       scales={'x': x_sc, 'y': y_sc}, visible=False)


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
Creating the Tooltip to display the required fields
bqplot's native Tooltip allows us to simply display the data fields we require on a mouse-interaction.
Can you write Python code for it?

tt = Tooltip(fields=['name', 'x', 'y'], labels=['Country Name', 'Income per Capita', 'Life Expectancy'])


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
Defining Axes and Scales
The inherent skewness of the income data favors the use of a LogScale. Also, since the color coding by regions does not follow an ordering, we use the OrdinalColorScale.
Can you write Python code for it?

x_sc = LogScale(min=income_min, max=income_max)
y_sc = LinearScale(min=life_exp_min, max=life_exp_max)
c_sc = OrdinalColorScale(domain=data['region'].unique().tolist(), colors=CATEGORY10[:6])
size_sc = LinearScale(min=pop_min, max=pop_max)

ax_y = Axis(label='Life Expectancy', scale=y_sc, orientation='vertical', side='left', grid_lines='solid')
ax_x = Axis(label='Income per Capita', scale=x_sc, grid_lines='solid')


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
On the slider value callback (a function that is triggered everytime the value of the slider is changed) we change the x, y and size co-ordinates of the Scatter. We also update the text of the Label to reflect the current year.
Can you write Python code for it?

def year_changed(change):
    wealth_scat.x, wealth_scat.y, wealth_scat.size = get_data(year_slider.value)
    year_label.text = [str(year_slider.value)]

year_slider.observe(year_changed, 'value')


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
Using a Slider to allow the user to change the year and a button for animation
Here we see how we can seamlessly integrate bqplot into the jupyter widget infrastructure.
Can you write Python code for it?

year_slider = IntSlider(min=1800, max=2008, step=1, description='Year', value=initial_year)


I am working on the file "2019-07-10-CICM/notebooks/wealth-of-nations.ipynb".
The first task is:
When the hovered_point of the Scatter plot is changed (i.e. when the user hovers over a different element), the entire path of that country is displayed by making the Lines object visible and setting it's x and y attributes.
Can you write Python code for it?

def hover_changed(change):
    if change.new is not None:
        nation_line.x = data['income'][change.new + 1]
        nation_line.y = data['lifeExpectancy'][change.new + 1]
        nation_line.visible = True
    else:
        nation_line.visible = False

wealth_scat.observe(hover_changed, 'hovered_point')


I am working on the file "2019-07-10-CICM/notebooks/widgets.ipynb".
The first task is:
Interactive Jupyter widgets
Can you write Python code for it?

slider = FloatSlider(
    value=7.5,
    min=5.0,
    max=10.0,
    step=0.1,
    description='Input:',
)

slider

slider

slider.value

slider.keys

slider.readout_format = '.4f'

text = FloatText(description='Value')
dlink((slider, 'value'), (text, 'value'))
text

slider


I am working on the file "2019-07-10-CICM/src/notebooks/DrawControl.ipynb".
The first task is:
It's possible to remove all drawings from the map
Can you write Python code for it?

dc.clear_circles()

dc.clear_polylines()

dc.clear_rectangles()

dc.clear_markers()

dc.clear_polygons()

dc.clear()


I am working on the file "2019-07-10-CICM/src/notebooks/DrawControl.ipynb".
The first task is:
Note that the style is preserved! If you wanted to change the style, you could edit the properties.style dictionary of the GeoJSON data. Or, you could even style the original path in the DrawControl by setting the polygon dictionary of that object. See the code for details.
Now let's add a DrawControl to this second map. For fun we will disable lines and enable circles as well and change the style a bit.
Can you write Python code for it?

dc2 = DrawControl(polygon={'shapeOptions': {'color': '#0000FF'}}, polyline={},
                  circle={'shapeOptions': {'color': '#0000FF'}})
m2.add_control(dc2)


I am working on the file "2019-07-10-CICM/src/notebooks/DrawControl.ipynb".
The first task is:
Now create the DrawControl and add it to the Map using add_control. We also register a handler for draw events. This will fire when a drawn path is created, edited or deleted (there are the actions). The  geo_json argument is the serialized geometry of the drawn path, along with its embedded style.
Can you write Python code for it?

dc = DrawControl(marker={'shapeOptions': {'color': '#0000FF'}},
                 rectangle={'shapeOptions': {'color': '#0000FF'}},
                 circle={'shapeOptions': {'color': '#0000FF'}},
                 circlemarker={},
                 )

def handle_draw(self, action, geo_json):
    print(action)
    print(geo_json)

dc.on_draw(handle_draw)
m.add_control(dc)


I am working on the file "2019-07-10-CICM/src/notebooks/bqplot.ipynb".
The first task is:
A simple plot with the pyplot API
Can you write Python code for it?

from bqplot import pyplot as plt

plt.figure(1)
n = 100
plt.plot(np.linspace(0.0, 10.0, n), np.cumsum(np.random.randn(n)),
         axes_options={'y': {'grid_lines': 'dashed'}})
plt.show()


I am working on the file "2019-07-10-CICM/src/notebooks/bqplot.ipynb".
The first task is:
Histogram
Can you write Python code for it?

plt.figure()
plt.hist(y_data, colors=['OrangeRed'])
plt.show()


I am working on the file "2019-07-10-CICM/src/notebooks/bqplot.ipynb".
The first task is:
Moving points around
Can you write Python code for it?


I am working on the file "2019-07-10-CICM/src/notebooks/bqplot.ipynb".
The first task is:
Scatter Plot
Can you write Python code for it?

plt.figure(title='Scatter Plot with colors')
plt.scatter(y_data_2, y_data_3, color=y_data)
plt.show()


I am working on the file "2019-07-10-CICM/src/notebooks/bqplot.ipynb".
The first task is:
Selections
Can you write Python code for it?


I am working on the file "2019-07-10-CICM/src/notebooks/bqplot.ipynb".
The first task is:
Use bqplot figures as input widgets
Can you write Python code for it?

xs = bq.LinearScale()
ys = bq.LinearScale()
x = np.arange(100)
y = np.cumsum(np.random.randn(2, 100), axis=1) #two random walks

line = bq.Lines(x=x, y=y, scales={'x': xs, 'y': ys}, colors=['red', 'green'])
xax = bq.Axis(scale=xs, label='x', grid_lines='solid')
yax = bq.Axis(scale=ys, orientation='vertical', tick_format='0.2f', label='y', grid_lines='solid')


I am working on the file "2019-07-10-CICM/src/notebooks/wealth-of-nations.ipynb".
The first task is:
Cleaning and Formatting JSON Data
Can you write Python code for it?


I am working on the file "2019-07-10-CICM/src/notebooks/wealth-of-nations.ipynb".
The first task is:
Creating the Figure
Can you write Python code for it?

time_interval = 10

fig = Figure(marks=[wealth_scat, year_label, nation_line], axes=[ax_x, ax_y],
             title='Health and Wealth of Nations', animation_duration=time_interval)


I am working on the file "2019-07-10-CICM/src/notebooks/wealth-of-nations.ipynb".
The first task is:
Creating the Label to display the year
Staying true to the d3 recreation of the talk, we place a Label widget in the bottom-right of the Figure (it inherits the Figure co-ordinates when no scale is passed to it). With enable_move set to True, the Label can be dragged around.
Can you write Python code for it?

year_label = Label(x=[0.75], y=[0.10], font_size=52, font_weight='bolder', colors=['orange'],
                   text=[str(initial_year)], enable_move=True)


I am working on the file "2019-07-10-CICM/src/notebooks/wealth-of-nations.ipynb".
The first task is:
On the slider value callback (a function that is triggered everytime the value of the slider is changed) we change the x, y and size co-ordinates of the Scatter. We also update the text of the Label to reflect the current year.
Can you write Python code for it?


I am working on the file "2019-07-10-CICM/src/notebooks/wealth-of-nations.ipynb".
The first task is:
Using a Slider to allow the user to change the year and a button for animation
Here we see how we can seamlessly integrate bqplot into the jupyter widget infrastructure.
Can you write Python code for it?


I am working on the file "2019-07-10-CICM/src/notebooks/wealth-of-nations.ipynb".
The first task is:
When the hovered_point of the Scatter plot is changed (i.e. when the user hovers over a different element), the entire path of that country is displayed by making the Lines object visible and setting it's x and y attributes.
Can you write Python code for it?


I am working on the file "2019-07-10-CICM/src/notebooks/widgets.ipynb".
The first task is:
Interactive Jupyter widgets
Can you write Python code for it?


I am working on the file "2019-07-10-CICM/src/notebooks/widgets.ipynb".
The first task is:
Widgets are represented in the back-end by a single object.  Each time a widget is displayed, a new representation of that same object is created in the front-end.  These representations are called views.
Can you write Python code for it?

slider

ft = FloatText()

def foo(change):
    ft.value = change.new

slider.observe(foo, names=['value'])

ft

from ipywidgets import HBox

HBox([slider, slider, ft])


I am working on the file "2019-09-04-EuroSciPy-jlab-debugger/presentation.ipynb".
The first task is:
2. Native debugging support for Jupyter Kernels
Can you write Python code for it?


I am working on the file "2019-09-04-EuroSciPy-jlab-debugger/presentation.ipynb".
The first task is:
New debug_request, debug_reply and debug_event messages
https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request

- Adding a debugger to xeus-python
- Driven by Johan Mabille

https://github.com/jupyter/jupyter_client/issues/446
https://github.com/jupyter/jupyter_client/pull/447
https://github.com/jupyterlab/jupyterlab/pull/6544
https://github.com/jupyter/notebook/pull/4672
https://github.com/jupyter/jupyter_server/pull/56

Debug Protocol
- Standing on the shoulder of giants
- Debug Adapter Protocol: https://microsoft.github.io/debug-adapter-protocol/specification (used in VS Code)
- ptvsd (Python Tools for Visual Studio debug server)

Source: https://microsoft.github.io/debug-adapter-protocol/overview

3. Debugger extension for JupyterLab
- Active development
- https://github.com/jupyterlab/debugger

Prototype
Switching to xpython
Can you write Python code for it?

for i in range(5):
    j = i + 1
    k = j ** 2
    print(j, k)

from ipywidgets import IntSlider

N = 5
slider = IntSlider(max=N)
slider

for i in range(N + 1):
    slider.value = i
    print(i)


I am working on the file "2019-09-04-EuroSciPy-jlab-debugger/presentation.ipynb".
The first task is:
PixieDebugger
Can you write Python code for it?

from IPython.display import YouTubeVideo

YouTubeVideo("Z-tPeEkVqjk", start=39, width=800, height=500)


I am working on the file "2019-09-04-EuroSciPy-jlab-debugger/presentation.ipynb".
The first task is:
PyCharm, Visual Studio and other IDEs

Visual Studio Code Cell Debugging
From https://twitter.com/davorabbit/status/1149062343231455238
Can you write Python code for it?

from IPython.display import Video

Video("./img/vscode-cell-debugging.mp4")


I am working on the file "2019-09-04-EuroSciPy-jlab-debugger/presentation.ipynb".
The first task is:
ipdb
Can you write Python code for it?

for i in range(5):
    j = i ** 2
    breakpoint()  # Python 3.7+
    # import ipdb; ipdb.set_trace()
    print(j)


I am working on the file "2019-10-17-read/inequality_compare.ipynb".
The first task is:
Plots
Can you write Python code for it?

import matplotlib.pyplot as plt
import math
%matplotlib inline


I am working on the file "2019-10-17-read/inequality_compare.ipynb".
The first task is:
动态改变 $n$
Can you write Python code for it?

n_range = list(range(10,201))
various_n = [generate_prob(n = n, p = 0.8, eps = 0.14) for n in n_range] # fix eps = 0.14 and p = 0.8
upper_Chebyshev = [1.0 / (4 * n *  0.14 ** 2) for n in n_range]
upper_Chernoff = [2 * math.exp(-2 * n *  0.14 ** 2) for n in n_range]

plt.semilogy(n_range, various_n, 'r-',label="Simulation")
plt.semilogy(n_range, upper_Chebyshev, 'g-',label="Chebyshev upper bound")
plt.semilogy(n_range, upper_Chernoff, 'b-',label="Chernoff upper bound")
plt.legend()
plt.xlabel("$n$")
plt.ylabel("$Prob$")
plt.title("$\epsilon = 0.14, p = 0.8$")
plt.savefig("./img/dynamic_n.png", dpi=200)
plt.show()


I am working on the file "2019-10-17-read/inequality_compare.ipynb".
The first task is:
动态改变 $p$
值的注意的是 Chernoff upper bound 与 $p$ 无关，但是 Chebyshev upper bound 与 $p$ 有关
Can you write Python code for it?

p_range = np.linspace(start=0.01, stop=0.99, num=200)
various_p = [generate_prob(n = 100, p = p, eps = 0.14) for p in p_range] # fix n=100 and eps = 0.14
upper_Chebyshev = [p * (1 - p) / (100 * 0.14 ** 2) for p in p_range]
upper_Chernoff = [2 * math.exp(-2 * 100 * 0.14 ** 2) for p in p_range]

plt.semilogy(p_range, various_p, 'r-',label="Simulation")
plt.semilogy(p_range, upper_Chebyshev, 'g-',label="Chebyshev upper bound")
plt.semilogy(p_range, upper_Chernoff, 'b-',label="Chernoff upper bound")
plt.legend()
plt.xlabel("$p$")
plt.ylabel("$Prob$")
plt.title("$\epsilon = 0.14, n = 100$")
plt.savefig("./img/dynamic_p.png", dpi=200)
plt.show()


I am working on the file "2019-12-11-erdc-xtensor/src/xtensor - xmesh extension module.ipynb".
The first task is:
2-D Mesh computed with xtensor, plotted with bqplot
Can you write Python code for it?

points = np.random.randn(100, 2)
mesh = pymesh.Mesh(points)

lines = np.stack(simplex.lines() for simplex in mesh)
plt.figure()

plt.plot(lines[:,:,0],
         lines[:,:,1],
         close_path=True,
         colors=['red'],
         stroke_width=1)

plt.scatter(x=points[:,0],
            y=points[:,1])

plt.show()


I am working on the file "2019-12-11-erdc-xtensor/src/xtensor - xmesh extension module.ipynb".
The first task is:
A simple application with ipywidgets and bqplot
Can you write Python code for it?

lines = np.stack(simplex.lines() for simplex in mesh)

def update_lines(change):
    with simplices.hold_sync():
        points = np.stack([scatter.x, scatter.y], axis=1)
        mesh = pymesh.Mesh(points)
        lines = np.stack(simplex.lines() for simplex in mesh)
        simplices.x = lines[:,:,0]
        simplices.y = lines[:,:,1]

plt.figure()
simplices = plt.plot(lines[:,:,0], lines[:,:,1], close_path=True, colors=['red'], stroke_width=1)
scatter = plt.scatter(x=points[:,0], y=points[:,1], enable_move=True)
plt.show()

scatter.observe(update_lines, names=['x', 'y'])


I am working on the file "2019/00-data-preparation/00-data-preparation-tutorial.ipynb".
The first task is:
Normalizar Dados
A normalização em scikit-learn refere-se a reescalonamento de cada observação (linha) para ter um comprimento de 1 (chamado de norma de unidade ou vetor com o comprimento de 1 em álgebra linear). Este método de pré-processamento pode ser útil para conjuntos de dados esparsos (quantidade grande de zeros) com atributos de escalas variáveis quando aplicados aos algoritmos que ponderam valores de entrada, como redes neurais e algoritmos que usam medidas de distância, como k-Nearest Neighbours. Você pode normalizar dados em Python com scikit-learn usando a classe Normalizer.
Can you write Python code for it?

# Normalize data (length of 1)
from sklearn.preprocessing import Normalizer
from pandas import read_csv
from numpy import set_printoptions
filename = 'pima-indians-diabetes.data'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(filename, names=names)
array = dataframe.values
# separate array into input and output components
X = array[:,0:8]
Y = array[:,8]
scaler = Normalizer().fit(X)
normalizedX = scaler.transform(X)
# summarize transformed data
set_printoptions(precision=3)
print(normalizedX[0:5,:])


I am working on the file "2019/00-data-preparation/00-data-preparation-tutorial.ipynb".
The first task is:
Padronizar dados
A padronização é uma técnica útil para transformar atributos assumindo que os mesmos seguem  uma distribuição gaussiana, modificando as médias e desvios padrão para uma distribuição gaussiana padrão com uma média de 0 e um desvio padrão de 1. É mais adequado para técnicas que assumem uma distribuição gaussiana nas variáveis de entrada e funcionam melhor com dados redimensionados, como regressão linear, regressão logística e análise de discriminação linear. Você pode padronizar dados usando scikit-learn com a classe StandardScaler
Can you write Python code for it?

# Standardize data (0 mean, 1 stdev)
from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
filename = 'pima-indians-diabetes.data'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(filename, names=names)
array = dataframe.values
# separate array into input and output components
X = array[:,0:8]
Y = array[:,8]
scaler = StandardScaler().fit(X)
rescaledX = scaler.transform(X)
# summarize transformed data
set_printoptions(precision=3)
print(rescaledX[0:5,:])


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/garimpagem-de-dados-02-numpy.ipynb".
The first task is:
Exercícios

Como calcular o tamanho da memória usada de qualquer array?
Crie a matriz 3x3 com valores em um range de 0 a 8
Crie um vetor randômico de tamanho 30 e calcule a média
Can you write Python code for it?

#1
t = np.zeros((10, 10))
print('%d bytes' % (t.size * t.itemsize))

#2
f = np.arange(9).reshape(3,3)
print(f)

#3
z = np.random.random(30)

print(z)
print(z.mean())


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/garimpagem-de-dados-02-pandas.ipynb".
The first task is:
Interagindo com datasets reais
Plataforma Kaggle - Competições de Ciências de Dados
Titanic: Machine Learning from Disaster
Nela, são providenciadas diversas informações sobre os passageiros em um Dataset de treino e um Dataset de teste, como idade, sexo, cabine, valor do tíquete pago, entre outros.
Além disso, no Dataset de treino é fornecida a variável alvo, que diz se um passageiro sobreviveu (valor = 1) ou não (valor = 0) ao naufrágio.
Já no Dataset de teste, são dadas as mesmas informações sobre outros passageiros, com exceção da variável alvo (a sobrevivência). Para os passageiros do Dataset de teste, você deverá prever se eles sobreviveram ou não, a partir das suas características, em comparação com as informações fornecidas no Dataset de treino.
Can you write Python code for it?

train = pd.read_csv('train.csv')

print(train.head()) # 5 primeiras linhas

print(train['Age'])

print(train.Sex)

print(train[['Sex','Age','Fare']])

print(train.ix[2])

print(train.ix[[0,10,50]])

print(train.tail()) # últimas 5 linhas

print(train.columns)

print(train.shape)

print(train.describe()) # calcula estatísticas para cada coluna numérica do DataFrame

print(train[train.Sex == "female", train.Age])


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/garimpagem-de-dados-02-pandas.ipynb".
The first task is:
Series
Can you write Python code for it?

a = pd.Series([20, 50, 190, 11, 76])
print(a)

dados = [20, 50, 190, 11, 76]
rotulos = ['a', 'b', 'c', 'd', 'e']
b = pd.Series(dados, index=rotulos)
print(b)

print(a[2])
print(b['c'])

a.plot(marker='o', grid=True);


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_basico.ipynb".
The first task is:
Acessando elementos de uma Series
Can you write Python code for it?


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_basico.ipynb".
The first task is:
Algumas operações permitidas em uma Series
Can you write Python code for it?

""" Multiplicação por um escalar """

obj2 * 2

""" Operações de vetor do numpy """

import numpy as np

np.exp(obj2)

""" Funções que funcionam com dictionaries """

'b' in obj2

'e' in obj2

""" Funções para identificar dados faltando """

obj4.isnull()

obj4.notnull()

""" Operações aritméticas com alinhamento automático dos índices """

obj3 + obj4


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_basico.ipynb".
The first task is:
DataFrame
Um DataFrame representa uma estrutura de dados tabular, semelhante a uma planilha de excel, contendo um conjunto ordenado de colunas, podendo ser cada uma de tipos de valores diferente. Um DataFrame possui um índice de linhas e um de colunas e pode ser encarado como um dict de Series.
Sua documentação completa se encontra em: http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html
Instanciando um DataFrame
Can you write Python code for it?

""" A partir de um dictionary de vetores """

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], \
        'year': [2000, 2001, 2002, 2001, 2002], \
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}

frame = pd.DataFrame(data)
frame

""" A partir de um dictionary em uma ordem específica das colunas """

pd.DataFrame(data, columns=['year', 'state', 'pop'])

""" A partir de um dictionary e dos índices das colunas e/ou dos índices das linhas """

frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five'])
frame2

""" A partir de um dictionary de dictionaries aninhados """

pop = {'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}

frame3 = pd.DataFrame(pop)
frame3


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_basico.ipynb".
The first task is:
Note que estas não são todas as formas possíveis de se fazê-lo. Para uma visão mais completa veja a seguinte tabela com as possíveis entradas para o construtor do DataFrame:
Type |Notes
-----|-----
2D ndarray | A matrix of data, passing optional row and column labels
dict of arrays, lists, or tuples | Each sequence becomes a column in the DataFrame. All sequences must be the same length.
NumPy structured/record array | Treated as the “dict of arrays” case
dict of Series | Each value becomes a column. Indexes from each Series are unioned together to form the result’s row index if no explicit index is passed.
dict of dicts | Each inner dict becomes a column. Keys are unioned to form the row index as in the “dict of Series” case.
list of dicts or Series | Each item becomes a row in the DataFrame. Union of dict keys or Series indexes become the DataFrame’s column labels
List of lists or tuples | Treated as the “2D ndarray” case
Another DataFrame | The DataFrame’s indexes are used unless different ones are passed
NumPy MaskedArray | Like the “2D ndarray” case except masked values become NA/missing in the DataFrame result
Manipulando linhas e colunas de um DataFrame
Can you write Python code for it?

""" Acessando colunas como em uma Series ou dictionary """

frame2['state']

""" Como colunas como um atributo """

frame2.year

""" Acessando linhas com o nome da linha """

frame2.ix['three']

""" Acessando linhas com o índice da linha """

frame2.ix[3]

""" Modificando uma coluna com um valor """

frame2['debt'] = 16.5
frame2

""" Modificando uma coluna com um vetor """

frame2['debt'] = np.arange(5.)
frame2

""" Modificando uma coluna com uma Series """

val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])

frame2['debt'] = val
frame2

""" Adicionando uma coluna que não existe """

frame2['eastern'] = frame2.state == 'Ohio'
frame2

""" Deletando uma coluna """

del frame2['eastern']
frame2.columns


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_basico.ipynb".
The first task is:
Series
Uma Series é um objeto semelhante a uma vetor que possui um vetor de dados e um vetor de labels associadas chamado index.
Sua documentação completa se encontra em: http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html#pandas.Series
Instanciando uma Series
Can you write Python code for it?

""" Apenas a partir dos valores """

obj = pd.Series([4, 7, -5, 3])
obj

obj.values

obj.index

""" A partir dos valores e dos índices """

obj2 = pd.Series([4, 7, -5, 3], index=['d','b','a','c'])
obj2

obj2.index

""" A partir de um dictionary """

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = pd.Series(sdata)
obj3

""" A partir de um dictionary e dos índices """

states = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = pd.Series(sdata, index=states)
obj4


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Ambos podem ser reindexados de uma só vez
Can you write Python code for it?


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Ao fazer essa indexação em um DataFrame recuperamos uma ou mais colunas.
Can you write Python code for it?

data = pd.DataFrame(np.arange(16).reshape((4, 4)), \
                    index=['Ohio', 'Colorado', 'Utah', 'New York'], \
                    columns=['one', 'two', 'three', 'four'])

data


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Aplicação de funções e mapeamento
As funções de vetor do numpy funcionam bem com objetos do pandas
Can you write Python code for it?

frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])
frame

np.abs(frame)


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
As colunas podem ser reindexadas utilizando o parâmetro columns
Can you write Python code for it?

states = ['Texas', 'Utah', 'California']

frame.reindex(columns=states)


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Com DataFrame, os valores de índice podem ser deletados de ambos os eixos
Can you write Python code for it?

data = pd.DataFrame(np.arange(16).reshape((4, 4)), \
                    index=['Ohio', 'Colorado', 'Utah', 'New York'], \
                    columns=['one', 'two', 'three', 'four'])

data

data.drop(['Colorado', 'Ohio'])

data.drop('two', axis=1)

data.drop(['two','four'], axis=1)


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Deletando entradas de um eixo
Can you write Python code for it?

obj = pd.Series(np.arange(5.), index=['a','b','c','d','e'])
obj

obj.drop('c')

obj.drop(['d','c'])


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
No caso dos DataFrame, o alinhamento é feito nas linhas e colunas ao mesmo tempo.
Can you write Python code for it?

df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'), index=['Ohio', 'Texas', 'Colorado'])
df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])

df1

df2

df1 + df2


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Outra operação frequente é aplicar uma função de um vetor unidimensional para cada coluna ou linha do DataFrame. O método apply faz exatamente isso.
Can you write Python code for it?

f = lambda x: x.max() - x.min()

frame.apply(f)

frame.apply(f, axis=1)


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Quando uma das Series não possui valor em um índice, no resultado é atribuído um resultado vazio naquele índice.
Can you write Python code for it?


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Reindexação
Can you write Python code for it?


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Se um valor não for encontrado nas colunas do DataFrame ou no índice da Series, o  resultado vai ser reindexado para formar a união dos dois
Can you write Python code for it?

series2 = pd.Series(range(3), index=['b', 'e', 'f'])

frame + series2


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Se você quer realizar a operação com a Series pelas colunas ao invés de pelas linhas é necessário utilizar um dos métodos aritméticos
Can you write Python code for it?

series3 = frame['d']

frame.sub(series3, axis=0)


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Segue alguns exemplos de formas de acessar os elemento em uma Series
Can you write Python code for it?

# pelo nome do índice

obj['b']

# pela posição no vetor de valores

obj[1]

# por um intervalo

obj[2:4]

# através de uma lista de nomes

obj[['b','a','d']]

# através de uma lista de posições

obj[[1,3]]

# através de uma operação booleana

obj[obj < 2]


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Series reorganizam os dados de acordo com o novo índice, introduzindo um valor vazio no caso de algum valor ausente.
Can you write Python code for it?

obj2 = obj.reindex(['a','b','c','d','e'])
obj2

obj.reindex(['a','b','c','d','e'], fill_value=0)


I am working on the file "2019/02-python-bibliotecas-manipulacao-dados/pandas_funcoes_importantes.ipynb".
The first task is:
Também é possível fazer operações aritméticas entre DataFrames e Series.
Can you write Python code for it?

frame = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])

series = frame.ix[0]

frame

series

frame - series


I am working on the file "2019/03-KNN/Aula 03 - KNN.ipynb".
The first task is:
1.3 Normalizar
Algumas colunas têm variância maior que outras, por isso é importante normalizar todas as colunas. Para isso calcularemos primeiro os mínimos e máximos.
Can you write Python code for it?

def dataset_minmax(dataset):
    minmax = list()
    for i in range(len(dataset[0])):
        col_values = [row[i] for row in dataset]
        value_min = min(col_values)
        value_max = max(col_values)
        minmax.append([value_min, value_max])
    return minmax

def normalize_dataset(dataset, minmax):
    for row in dataset:
        for i in range(len(row)):
            row[i] = (row[i] - minmax[i][0]) / (minmax[i][1] - minmax[i][0])


I am working on the file "2019/03-KNN/Aula 03 - KNN.ipynb".
The first task is:
2. Calcular Distância Euclidiana
O primeiro passo necessário é calcular a distância entre duas linhas em um conjunto de dados. Linhas de dados
são constituídos principalmente por números e uma maneira fácil de calcular a distância entre duas linhas ou
vetores de números é desenhar uma linha reta. Isso faz sentido em 2D ou 3D e escala muito bem
para maiores dimensões. Podemos calcular a distância da linha reta entre dois vetores usando
a medida de distância euclidiana. É calculado como a raiz quadrada da soma do quadrado
diferenças entre os dois vetores. Com a distância euclidiana, quanto menos o valor, maior a similaridade. O valor $0$ significa que não há nenhuma diferença entre dois registros.
Abaixo temos a função que calcula isso:
Can you write Python code for it?


I am working on the file "2019/03-KNN/Aula 03 - KNN.ipynb".
The first task is:
4. Fazer Predições
Os vizinhos mais semelhantes coletados do conjunto de dados de treinamento podem ser usados para fazer previsões.
No caso da classificação, podemos retornar a classe mais representada entre os vizinhos. Podemos conseguir isso executando a função max( ) na lista de valores de saída dos vizinhos. Dada uma lista de valores de classe observadas nos vizinhos, a função max( ) toma um conjunto de valores de classe únicos e chama a contagem na lista de valores de classe para cada valor de classe no conjunto.
Abaixo está a função denominada predict_classification( ) que implementa isso.
Can you write Python code for it?


I am working on the file "2019/03-KNN/Aula 03 - KNN.ipynb".
The first task is:
5.2 Avaliar Algoritmo
Abaixo temos a função que avalia o algoritmo usando uma divisão de validação cruzada.
Can you write Python code for it?

def evaluate_algorithm(dataset, algorithm, n_folds, *args):
    folds = cross_validation_split(dataset, n_folds)
    scores = list()
    for fold in folds:
        train_set = list(folds)
        train_set.remove(fold)
        train_set = sum(train_set, [])
        test_set = list()
        for row in fold:
            row_copy = list(row)
            test_set.append(row_copy)
        row_copy[-1] = None
        predicted = algorithm(train_set, test_set, *args)
        actual = [row[-1] for row in fold]
        accuracy = accuracy_metric(actual, predicted)
        scores.append(accuracy)
    return scores


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
1.2 Dividir Arquivo
Em seguida, precisamos dividir os dados em um conjunto de dados de treinamento, o qual possa ser usado pelo Naive Bayes para fazer previsões e um conjunto de dados de teste para que possamos usar para avaliar a precisão do modelo. Precisamos dividir o conjunto de dados aleatoriamente em treino e teste, em conjuntos de dados com uma proporção de 67% de treinamento e 33% de teste (esta é uma razão comum para testar um algoritmo em um conjunto de dados).
Abaixo está a função splitDataset () que dividirá um determinado conjunto de dados em uma proporção de divisão determinada.
Can you write Python code for it?

import random
def splitDataset(dataset, splitRatio):
    trainSize = int(len(dataset) * splitRatio)
    trainSet = []
    copy = list(dataset)
    while len(trainSet) < trainSize:
        index = random.randrange(len(copy))
        trainSet.append(copy.pop(index))
    return [trainSet, copy]


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
2. Sumarizar Dados
O modelo do Naive Bayes é composto basicamente pela sumarização do conjunto de dados de treinamento. Este sumário é então usado ao fazer previsões.
O resumo dos dados de treinamento coletados envolve a média e o desvio padrão para cada atributo, pelo valor da classe. Por exemplo, se houver dois valores de classe e 7 atributos numéricos, então precisamos de um desvio padrão e médio para cada combinação de atributo (7) e valor de classe (2), ou seja, 14 resumos de atributos. Estes são necessários ao fazer previsões para calcular a probabilidade de valores de atributos específicos pertencentes a cada valor de classe.
Para sumarizar os dados criamos as seguintes subtarefas:

Separar dados por classe
Calcular Média
Calcular o desvio padrão
Conjunto de dados de resumo
Resumir atributos por classe
Separar dados por classe

2.1 Separar dados por classe
A primeira tarefa é separar as instâncias do conjunto de dados de treinamento pelo valor da classe para que possamos calcular as estatísticas para cada classe. Podemos fazer isso criando um mapa de cada valor de classe para uma lista de instâncias que pertencem a essa classe e classificar todo o conjunto de dados de instâncias nas listas apropriadas.
A função separadaByClass () abaixo faz isso.
Can you write Python code for it?

def separateByClass(dataset):
    separated = {}
    for i in range(len(dataset)):
        vector = dataset[i]
        if (vector[-1] not in separated):
            separated[vector[-1]] = []
        separated[vector[-1]].append(vector)
    return separated


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
2.2 Calcular Média e Desvio Padrão
Precisamos calcular a média de cada atributo para um valor de classe. A média é a tendência central central ou central dos dados, e vamos usá-lo como meio de nossa distribuição gaussiana ao calcular probabilidades.
Também precisamos calcular o desvio padrão de cada atributo para um valor de classe. O desvio padrão descreve a variação da disseminação dos dados, e vamos usá-lo para caracterizar a propagação esperada de cada atributo em nossa distribuição gaussiana ao calcular probabilidades.
O desvio padrão é calculado como a raiz quadrada da variância. A variância é calculada como a média das diferenças quadradas para cada valor de atributo da média. Observe que estamos usando o método N-1, que subtrai 1 do número de valores de atributo ao calcular a variância.
Can you write Python code for it?

import math
def mean(numbers):
    return sum(numbers)/float(len(numbers))

def stdev(numbers):
    avg = mean(numbers)
    variance = sum([pow(x-avg,2) for x in numbers])/float(len(numbers)-1)
    return math.sqrt(variance)


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
2.2 Sumarizar os dados
Agora temos as ferramentas para resumir um conjunto de dados. Para uma determinada lista de instâncias (para um valor de classe), podemos calcular a média e o desvio padrão para cada atributo.
A função zip agrupa os valores de cada atributo em nossas instâncias de dados em suas próprias listas para que possamos calcular os valores de desvio padrão e média para o atributo.
Can you write Python code for it?

def summarize(dataset):
    summaries = [(mean(attribute), stdev(attribute)) for attribute in zip(*dataset)]
    del summaries[-1]
    return summaries


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
2.3 Sumarizar Atributos por classes
Podemos juntar tudo ao separar nosso conjunto de dados de treinamento em instâncias agrupadas por classe, usando a função summarizeByClass()
Can you write Python code for it?

def summarizeByClass(dataset):
    separated = separateByClass(dataset)
    summaries = {}
    for classValue, instances in separated.items():
        summaries[classValue] = summarize(instances)
    return summaries


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
3. Realizar as Predição
Agora estamos prontos para fazer previsões usando os resumos preparados a partir dos nossos dados de treinamento. As previsões envolvem o cálculo da probabilidade de uma dada instância de dados pertencer a cada classe e a seleção da classe com a maior probabilidade de previsão.
Podemos dividir essa parte nas seguintes tarefas:

Calcular a função de densidade de probabilidade gaussiana
Calcular probabilidades das classes
Fazer uma previsão
Fazer várias previsões
Obter acurácia

3.1 Calcular a função de densidade de probabilidade gaussiana
Podemos usar uma função gaussiana para estimar a probabilidade de um determinado valor de atributo, dada a média conhecida e o desvio padrão para o atributo estimado a partir dos dados de treinamento.
Dado que os resumos de atributos para cada atributo e valor de classe, o resultado é a probabilidade condicional de um determinado valor de atributo dado um valor de classe.
Veja as referências para os detalhes desta equação para a função de densidade de probabilidade gaussiana. Em resumo, estamos conectando nossos detalhes conhecidos ao Gauss (valor do atributo, média e desvio padrão) e recuperando a probabilidade de que nosso valor de atributo pertença à classe.
Na função calcularProbability (), calculamos o expoente primeiro, depois calculamos a divisão principal. Isso nos permite ajustar a equação bem em duas linhas.
Can you write Python code for it?

def calculateProbability(x, mean, stdev):
    exponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))
    return (1 / (math.sqrt(2*math.pi) * math.pow(stdev, 2))) * exponent


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
3.3 Fazer a Predição
Agora podemos calcular a probabilidade de uma instância de dados pertencente a cada valor de classe, podemos procurar a maior probabilidade e retornar a classe associada.
A função predict() realiza esta tarefa.
Can you write Python code for it?

def predict(summaries, inputVector):
    probabilities = calculateClassProbabilities(summaries, inputVector)
    bestLabel, bestProb = None, -1
    for classValue, probability in probabilities.items():
        if bestLabel is None or probability > bestProb:
            bestProb = probability
            bestLabel = classValue
    return bestLabel


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
3.5 Calcular Acurácia
As previsões podem ser comparadas com os valores de classe no conjunto de dados de teste. A acurácia da classificação pode ser calculada como uma relação de precisão entre 0 e 100%. A função getAccuracy () calculará essa relação de precisão.
Can you write Python code for it?

def getAccuracy(testSet, predictions):
    correct = 0
    for i in range(len(testSet)):
        if testSet[i][-1] == predictions[i]:
            correct += 1
    return (correct/float(len(testSet))) * 100.0


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 1
Teste esta função carregando o dataset pima-indians-diabetes.data e imprime o número de instancias carregadas da seguinte forma "Arquivo carregado pima-indians-diabetes.data com XXX linhas"
Can you write Python code for it?


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 10
Teste a função acima, usando um pequeno conjunto de dados. Exemplo de saída:
"Predições: Sumarios {'A': [(1, 0.5)], 'B': [(20, 5.0)]} Teste [[1.1, '?'], [19.1, '?']] Classes Preditas['A', 'B']"
Can you write Python code for it?


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 2
Teste esta função definindo um dataset mockado com 5 instancias, divida este arquivo em trainamento e teste. Imprima os conjuntos de treinamento e teste gerados, por exemplo, imprimindo:
"Dividiu arquivo com 5 linhas em arquivo de treino com [[2], [5], [4]] e de teste com [[1], [3]]"
Can you write Python code for it?


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 3
Teste este função com alguns exemplos de dados sintéticos e imprima as classes separadas com seus respectivas instancias. Perceba no exemplo acima que a classe se refere ao último elemento do vetor. Segue um exemplo de saída:
"Instancias separadas por classes: {1: [[1, 20, 1], [3, 22, 1]], 0: [[2, 21, 0]]}"
Can you write Python code for it?


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 4
Crie alguns dados fictícios e teste as funções criadas.Exemplo:
"Cálculo de [1, 2, 3, 4, 5]: média=3.0, stdev=1.5811388300841898"
Can you write Python code for it?


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 5
Crie alguns dados fictícios e teste as funções criadas.Exemplo de saída:
"Sumário dos atributos: [(2.0, 1.0), (21.0, 1.0)]"
Can you write Python code for it?


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 6
Teste a função acima, usando um pequeno conjunto de dados. Exemplo de saída:
Resumo por classe: {1: [(2.0, 1.4142135623730951), (21.0, 1.4142135623730951)], 0: [(3.0, 1.4142135623730951), (21.5, 0.7071067811865476)]}
Can you write Python code for it?


I am working on the file "2019/04-naive-bayes/Naive_Bayes_Tutorial_01.ipynb".
The first task is:
Exercicio 8
Teste a função acima, usando um pequeno conjunto de dados. Exemplo de saída:
"Probabilidades para cada classe: {0: 0.7820853879509118, 1: 6.298736258150442e-05}"
Can you write Python code for it?


I am working on the file "2019/05-linear-regression/Linear_Regression_Tutorial.ipynb".
The first task is:
2.3 Estimativa dos Coeficientes
Agora, devemos estimar os valores dos dois coeficientes em regressão linear simples. O primeiro é B1 que pode ser estimado como:

Podemos simplificar esta fórmula usando as funcões covariance e variance apresentadas acima, conforme a fórmula abaixo.

Em seguida, precisamos estimar um valor para B0, também chamado de interceptação, pois controla o ponto inicial da linha onde ele intersecta o eixo y.

Mais uma vez, sabemos como estimar B1 e temos uma função para estimar a média (). Podemos juntar tudo isso em uma função denominada coefficients () que leva o conjunto de dados como um argumento e retorna os coeficientes.
Can you write Python code for it?

# Calculate coefficients
def coefficients(dataset):
      x = [row[0] for row in dataset]
      y = [row[1] for row in dataset]
      x_mean, y_mean = mean(x), mean(y)
      b1 = covariance(x, x_mean, y, y_mean) / variance(x, x_mean)
      b0 = y_mean - b1 * x_mean
      return [b0, b1]


I am working on the file "2019/05-linear-regression/Linear_Regression_Tutorial.ipynb".
The first task is:
Exercicio 1
(a) Junte as duas funções acima e teste-as em um conjunto de dados pequeno dado. Utiloze como exemplo, o pequeno conjunto de dados de valores x e y.
x |  y
--| -
1 | 1
2 | 3
4 | 3
3 | 2
5 | 5
(b) Em seguida crie um gráfico onde voce plot esses pontos
Can you write Python code for it?

## COLOQUE SEU CODIGO AQUI
x=[1,2,4,3,5]
y=[1,3,3,2,5]
print('Média de valores de x = {} | Variancia dos valores de x = {}'.format(mean(x),variance(x,mean(x))))
print('----------------------')
print('Média de valores de y = {} | Variancia dos valores de y = {}'.format(mean(y),variance(y,mean(y))))

## FAÇA O PLOT DOS DADOS AQUI
%matplotlib inline
import matplotlib.pyplot as plt


I am working on the file "2019/05-linear-regression/Linear_Regression_Tutorial.ipynb".
The first task is:
Exercicio 2
Teste o cálculo da covariância no mesmo pequeno conjunto de dados apresentado na
seção anterior.
Can you write Python code for it?

## COLOQUE SEU CODIGO AQUI
print(covariance(x,mean(x),y,mean(y)))


I am working on the file "2019/05-linear-regression/Linear_Regression_Tutorial.ipynb".
The first task is:
Exercicio 3
Estenda o exercício anterior incluindo o cáculo dos coeficientes para os dados sintetizados.
Can you write Python code for it?


I am working on the file "2019/05-linear-regression/Linear_Regression_Tutorial.ipynb".
The first task is:
Exercicio 4
Agora junte tudo que foi criado para fazer previsões para o nosso conjunto de dados de teste.
Can you write Python code for it?


I am working on the file "2019/05-linear-regression/Linear_Regression_Tutorial.ipynb".
The first task is:
Exercício 5
Crie um scatter plot para mostrar as previsões como uma linha e compará-lo com o conjunto de dados original.
Can you write Python code for it?


I am working on the file "2019/05-linear-regression/Linear_Regression_Tutorial.ipynb".
The first task is:
Para avaliar o modelo
 adicionaremos uma função para gerenciar a avaliação das previsões denominadas evaluate_algorithm () e outra função para estimar o erro quadrático médio da raiz das previsões denominadas métrica rmse_metric (). Veja as funções abaixo:
Can you write Python code for it?

from math import sqrt

# Calculate root mean squared error
def rmse_metric(actual, predicted):
  sum_error = 0.0
  for i in range(len(actual)):
    prediction_error = predicted[i] - actual[i]
    sum_error += (prediction_error ** 2)
  mean_error = sum_error / float(len(actual))
  return sqrt(mean_error)

# Evaluate regression algorithm on training dataset
def evaluate_algorithm(dataset, algorithm):
  test_set = list()
  for row in dataset:
    row_copy = list(row)
    row_copy[-1] = None
    test_set.append(row_copy)
  predicted = algorithm(dataset, test_set)
  print(predicted)
  actual = [row[-1] for row in dataset]
  rmse = rmse_metric(actual, predicted)
  return rmse


I am working on the file "2019/06-decision-tree/Exercise_Tree_Decision.ipynb".
The first task is:
Definição da acurácia
Can you write Python code for it?

accuracy = model.score(X_test, y_test)*100
print('Accuracy: %s%%' % accuracy)

maxAccuracy = 0
valueI, valueJ = '', ''
for i in range(2, 20):
    for j in range(2, 20):

        model = DecisionTreeClassifier(criterion='gini', max_depth=i, min_samples_split= j)
        model.fit(X_train, y_train)
        predicao = model.predict(X_test)
        accuracy = model.score(X_test, y_test)*100
        if accuracy > maxAccuracy:
            maxAccuracy = accuracy
            valueI, valueJ = i,j
print('I: {0}, J:{1} Accuracy: {2}%'.format(valueI, valueJ, maxAccuracy))


I am working on the file "2019/06-decision-tree/Exercise_Tree_Decision.ipynb".
The first task is:
Deifinição do modelo
Can you write Python code for it?

model = DecisionTreeClassifier(criterion='gini', max_depth=4, min_samples_split= 20)


I am working on the file "2019/06-decision-tree/Exercise_Tree_Decision.ipynb".
The first task is:
Divisão do dataset em treino e teste
Can you write Python code for it?

X_train, X_test, y_train, y_test = train_test_split(X, Y, train_size=0.8, test_size= 0.2, random_state=0)


I am working on the file "2019/06-decision-tree/Exercise_Tree_Decision.ipynb".
The first task is:
Predição utilizando o X_test
Can you write Python code for it?


I am working on the file "2019/06-decision-tree/Exercise_Tree_Decision.ipynb".
The first task is:
Treinamento do modelo
Can you write Python code for it?


I am working on the file "2019/06-decision-tree/Tutorial 11 (scikitlearn) - Árvores de Classificação e Regressão.ipynb".
The first task is:
3. Treinar o algoritmo
Can you write Python code for it?

from sklearn.tree import DecisionTreeClassifier


I am working on the file "2019/06-decision-tree/Tutorial 11 (scikitlearn) - Árvores de Classificação e Regressão.ipynb".
The first task is:
Agora iremos treinar o nosso modelo, utilizando a função fit do sklearn, usaremos os conjuntos de dados de treino que tínhamos preparados anteriormente.
Can you write Python code for it?


I am working on the file "2019/06-decision-tree/Tutorial 11 (scikitlearn) - Árvores de Classificação e Regressão.ipynb".
The first task is:
O próximo passo é dividir o conjunto de dados, em dados de treino e de teste. Para isso usaremos a função train_test_split da biblioteca sklearn.
Can you write Python code for it?

from sklearn.model_selection import train_test_split


I am working on the file "2019/06-decision-tree/Tutorial 11 (scikitlearn) - Árvores de Classificação e Regressão.ipynb".
The first task is:
Se desejar visualizar todo o dataset executa a seguinte linha de código.
Can you write Python code for it?


I am working on the file "2019/06-decision-tree/Tutorial 11 (scikitlearn) - Árvores de Classificação e Regressão.ipynb".
The first task is:
Utilizaremos a função head() para visualizar as primeiras linhas do dataframe.
Can you write Python code for it?


I am working on the file "2019/06-decision-tree/Tutorial 11 (scikitlearn) - Árvores de Classificação e Regressão.ipynb".
The first task is:
Vamos utilizar a função DecisionTreeClassifier para modelar. O parâmetro criterion define a função utilizada para medir a qualidade da divisão. No nosso caso definimos o critério com 'gini'.
O coeficiente é uma função de custo utilizada para avaliar divisões no dataset. Uma divisão neste envolve um atributo de entrada e um valor para este atributo. Uma separação perfeita resulta em um valor de Gini igual a 0, no pior caso, ou seja, no caso em que a separação resulta em 50/50, resulta em um valor de Gini igual a 0.5.
O parâmetro max_depth define a máxima profundidade de uma árvore: Isso é o número máximo de nós da raiz da árvore. Uma vez que a profundidade máxima é atingida devemos parar de adicionar novos nós. Árvores muito profundas são mais complexas e mais prováveis de superar os dados de treinamento.
O parâmetro min_samples_split define o número mínimo de registros nos nós: É o número mínimo de padrões de treinamento que um nó é responsável. Uma vez menor ou igual que o mínimo, devemos parar de dividir e adicionar novos nós. Nós que são responsaveis por poucos padrões de treinamento são muitos específicos.
Esta função aceita ainda outros parâmetros, mas para o nosso caso estes são suficientes.
Can you write Python code for it?

model = DecisionTreeClassifier(criterion='gini', max_depth= 5, min_samples_split= 10)


I am working on the file "2019/06-decision-tree/Tutorial 11 (scikitlearn) - Árvores de Classificação e Regressão.ipynb".
The first task is:
É natural querermos saber quão bom é o desempenho do modelo que desenvolvemos sobre o dataset. Para calcular a acurácia podemos utilizar a função score do sklearn.tree.
Can you write Python code for it?

accuracy = model.score(X_test, y_test)*100

print('Accuracy: %s%%' % accuracy)


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
1.2 Definir os clusters
Na segunda etapa do algoritmo serão definidos o grupo de cada dado, de acordo com os centróides calculados.
1.2.1 Função de distância
Codifique a função de distância euclidiana entre dois pontos (a, b).
Definido pela equação:
$$ dist(a, b) = \sqrt{(a_1-b_1)^{2}+(a_2-b_2)^{2}+ ... + (a_n-b_n)^{2}} $$
$$ dist(a, b) = \sqrt{\sum_{i=1}^{n}(a_i-b_i)^{2}} $$
Can you write Python code for it?

def euclidean_distance(a, b):
    """
    Calcula a distância euclidiana entre os pontos a e b

    Argumentos:
    a -- Um ponto no espaço - [1,n]
    b -- Um ponto no espaço - [1,n]

    Retornos:
    distance -- Distância euclidiana entre os pontos
    """

    #### CODE HERE ####

    distance = np.sqrt(np.sum(np.square(a-b)))

    ### END OF CODE ###

    return distance


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
1.2.2 Calcular o centroide mais próximo
Utilizando a função de distância codificada anteriormente, complete a função abaixo para calcular o centroid mais próximo de um ponto qualquer.

Dica: https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmin.html
Can you write Python code for it?

def nearest_centroid(a, centroids):
    """
    Calcula o índice do centroid mais próximo ao ponto a

    Argumentos:
    a -- Um ponto no espaço - [1,n]
    centroids -- Lista com os centróides - [k,n]

    Retornos:
    nearest_index -- Índice do centróide mais próximo
    """

    #### CODE HERE ####

    distance_zeros = np.zeros(centroids.shape[0])
    for index, centroid in enumerate(centroids):
        distance = euclidean_distance(a, centroid)
        distance_zeros[index] = distance

    nearest_index = np.argmin(distance_zeros)

    ### END OF CODE ###

    return nearest_index


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
1.2.3 Calcular centroid mais próximo de cada dado do dataset
Utilizando a função anterior que retorna o índice do centroid mais próximo, calcule o centroid mais próximo de cada dado do dataset.
Can you write Python code for it?

def all_nearest_centroids(dataset, centroids):
    """
    Calcula o índice do centroid mais próximo para cada
    ponto do dataset

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]

    Retornos:
    nearest_indexes -- Índices do centróides mais próximos - [m,1]
    """

    #### CODE HERE ####

    nearest_indexes = np.zeros(dataset.shape[0])

    for index, a in enumerate(dataset):
        nearest_indexes[index] = nearest_centroid(a, centroids)

    ### END OF CODE ###

    return nearest_indexes


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
1.3 Métrica de avaliação
Após formar os clusters, como sabemos se o resultado gerado é bom? Para isso, precisamos definir uma métrica de avaliação.
O algoritmo K-means tem como objetivo escolher centróides que minimizem a soma quadrática das distância entre os dados de um cluster e seu centróide. Essa métrica é conhecida como inertia.
$$\sum_{i=0}^{n}\min_{c_j \in C}(||x_i - c_j||^2)$$
A inertia, ou o critério de soma dos quadrados dentro do cluster, pode ser reconhecido como uma medida de o quão internamente coerentes são os clusters, porém ela sofre de alguns inconvenientes:

A inertia pressupõe que os clusters são convexos e isotrópicos, o que nem sempre é o caso. Desta forma, pode não representar bem em aglomerados alongados ou variedades com formas irregulares.
A inertia não é uma métrica normalizada: sabemos apenas que valores mais baixos são melhores e zero é o valor ótimo. Mas em espaços de dimensões muito altas, as distâncias euclidianas tendem a se tornar infladas (este é um exemplo da chamada “maldição da dimensionalidade”). A execução de um algoritmo de redução de dimensionalidade, como o PCA, pode aliviar esse problema e acelerar os cálculos.

Fonte: https://scikit-learn.org/stable/modules/clustering.html
Para podermos avaliar os nosso clusters, codifique a métrica da inertia abaixo, para isso você pode utilizar a função de distância euclidiana construída anteriormente.
$$inertia = \sum_{i=0}^{n}\min_{c_j \in C} (dist(x_i, c_j))^2$$
Can you write Python code for it?

def inertia(dataset, centroids, nearest_indexes):
    """
    Soma das distâncias quadradas das amostras para o
    centro do cluster mais próximo.

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]
    nearest_indexes -- Índices do centróides mais próximos - [m,1]

    Retornos:
    inertia -- Soma total do quadrado da distância entre
    os dados de um cluster e seu centróide
    """

    #### CODE HERE ####

    inertia = 0
    for index, centroid in enumerate(centroids):
        dataframe = dataset[nearest_indexes == index,:]
        for a in dataframe:
            inertia += np.square(euclidean_distance(a,centroid))

    ### END OF CODE ###

    return inertia


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
1.4 Atualizar os clusters
Nessa etapa, os centróides são recomputados. O novo valor de cada centróide será a media de todos os dados atribuídos ao cluster.
Can you write Python code for it?

def update_centroids(dataset, centroids, nearest_indexes):
    """
    Atualiza os centroids

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]
    nearest_indexes -- Índices do centróides mais próximos - [m,1]

    Retornos:
    centroids -- Lista com centróides atualizados - [k,n]
    """

    #### CODE HERE ####

    for index, centroid in enumerate(centroids):
        dataframe = dataset[nearest_indexes == index,:]
        if(dataframe.size != 0):
            centroids[index] = np.mean(dataframe, axis=0)

    ### END OF CODE ###

    return centroids


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
2.2 Comparar com algoritmo do Scikit-Learn
Use a implementação do algoritmo do scikit-learn do K-means para o mesmo conjunto de dados. Mostre o valor da inércia  e os conjuntos gerados pelo modelo. Você pode usar a mesma estrutura da célula de código anterior.

Dica: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans
Can you write Python code for it?

from sklearn.cluster import KMeans as scikit_KMeans

scikit_kmeans = scikit_KMeans(n_clusters=3)
scikit_kmeans.fit(dataset)

print("Inércia = ", scikit_kmeans.inertia_)

plt.scatter(dataset[:,0], dataset[:,1], c=scikit_kmeans.labels_)
plt.scatter(scikit_kmeans.cluster_centers_[:,0],
            scikit_kmeans.cluster_centers_[:,1], c='red')

plt.show()


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
3. Método do cotovelo
Implemete o método do cotovelo e mostre o melhor K para o conjunto de dados.
Can you write Python code for it?

n_clusters_test = 8

n_sequence = np.arange(1, n_clusters_test+1)
inertia_vec = np.zeros(n_clusters_test)

for index, n_cluster in enumerate(n_sequence):
    inertia_vec[index] = KMeans(n_clusters=n_cluster).fit(dataset).inertia_

plt.plot(n_sequence, inertia_vec, 'ro-')
plt.show()


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
Criar um novo dataset para práticar
Can you write Python code for it?

# Selecionar três centróides
cluster_center_1 = np.array([2,3])
cluster_center_2 = np.array([6,6])
cluster_center_3 = np.array([10,1])

# Gerar amostras aleátorias a partir dos centróides escolhidos
cluster_data_1 = np.random.randn(100, 2) + cluster_center_1
cluster_data_2 = np.random.randn(100,2) + cluster_center_2
cluster_data_3 = np.random.randn(100,2) + cluster_center_3

new_dataset = np.concatenate((cluster_data_1, cluster_data_2,
                         cluster_data_3), axis = 0)

plt.scatter(new_dataset[:,0], new_dataset[:,1], s=10)
plt.show()


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
Teste a função codificada executando o código abaixo.
Can you write Python code for it?

tmp_data = np.array([[1,2,3],[3,6,5],[4,5,6]])
tmp_centroide = np.array([[2,3,4]])

tmp_nearest_indexes = all_nearest_centroids(tmp_data, tmp_centroide)
if inertia(tmp_data, tmp_centroide, tmp_nearest_indexes) == 26:
    print("Inertia calculada corretamente!")
else:
    print("Função de inertia incorreta!")

# Use a função para verificar a inertia dos seus clusters
inertia(dataset, centroids, nearest_indexes)


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
Teste a função criada visualizando os cluster formados.
Can you write Python code for it?

nearest_indexes = all_nearest_centroids(dataset, centroids)

plt.scatter(dataset[:,0], dataset[:,1], c=nearest_indexes)
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red', s=100)
plt.show()


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
Verifique o resultado do algoritmo abaixo!
Can you write Python code for it?

kmeans = KMeans(n_clusters=3)
kmeans.fit(dataset)

print("Inércia = ", kmeans.inertia_)

plt.scatter(dataset[:,0], dataset[:,1], c=kmeans.labels_)
plt.scatter(kmeans.cluster_centers_[:,0],
            kmeans.cluster_centers_[:,1], marker='^', c='red', s=100)
plt.show()


I am working on the file "2019/09-clustering/Notebook_KMeans_Answer.ipynb".
The first task is:
Visualize os clusters formados
Can you write Python code for it?

nearest_indexes = all_nearest_centroids(dataset, centroids)

# Plota os os cluster ------------------------------------------------
plt.scatter(dataset[:,0], dataset[:,1], c=nearest_indexes)

# Plota os centroids
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red', s=100)
for index, centroid in enumerate(centroids):
    dataframe = dataset[nearest_indexes == index,:]
    for data in dataframe:
        plt.plot([centroid[0], data[0]], [centroid[1], data[1]],
                 c='lightgray', alpha=0.3)
plt.show()


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
1.2 Definir os clusters
Na segunda etapa do algoritmo serão definidos o grupo de cada dado, de acordo com os centróides calculados.
1.2.1 Função de distância
Codifique a função de distância euclidiana entre dois pontos (a, b).
Definido pela equação:
$$ dist(a, b) = \sqrt{(a_1-b_1)^{2}+(a_2-b_2)^{2}+ ... + (a_n-b_n)^{2}} $$
$$ dist(a, b) = \sqrt{\sum_{i=1}^{n}(a_i-b_i)^{2}} $$
Can you write Python code for it?

def euclidean_distance(a, b):
    """
    Calcula a distância euclidiana entre os pontos a e b

    Argumentos:
    a -- Um ponto no espaço - [1,n]
    b -- Um ponto no espaço - [1,n]

    Retornos:
    distance -- Distância euclidiana entre os pontos
    """

    #### CODE HERE ####

    ### END OF CODE ###

    return distance


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
1.2.3 Calcular centroid mais próximo de cada dado do dataset
Utilizando a função anterior que retorna o índice do centroid mais próximo, calcule o centroid mais próximo de cada dado do dataset.
Can you write Python code for it?

def all_nearest_centroids(dataset, centroids):
    """
    Calcula o índice do centroid mais próximo para cada
    ponto do dataset

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]

    Retornos:
    nearest_indexes -- Índices do centróides mais próximos - [m,1]
    """

    #### CODE HERE ####

    ### END OF CODE ###

    return nearest_indexes


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
1.3 Métrica de avaliação
Após formar os clusters, como sabemos se o resultado gerado é bom? Para isso, precisamos definir uma métrica de avaliação.
O algoritmo K-means tem como objetivo escolher centróides que minimizem a soma quadrática das distância entre os dados de um cluster e seu centróide. Essa métrica é conhecida como inertia.
$$\sum_{i=0}^{n}\min_{c_j \in C}(||x_i - c_j||^2)$$
A inertia, ou o critério de soma dos quadrados dentro do cluster, pode ser reconhecido como uma medida de o quão internamente coerentes são os clusters, porém ela sofre de alguns inconvenientes:

A inertia pressupõe que os clusters são convexos e isotrópicos, o que nem sempre é o caso. Desta forma, pode não representar bem em aglomerados alongados ou variedades com formas irregulares.
A inertia não é uma métrica normalizada: sabemos apenas que valores mais baixos são melhores e zero é o valor ótimo. Mas em espaços de dimensões muito altas, as distâncias euclidianas tendem a se tornar infladas (este é um exemplo da chamada “maldição da dimensionalidade”). A execução de um algoritmo de redução de dimensionalidade, como o PCA, pode aliviar esse problema e acelerar os cálculos.

Fonte: https://scikit-learn.org/stable/modules/clustering.html
Para podermos avaliar os nosso clusters, codifique a métrica da inertia abaixo, para isso você pode utilizar a função de distância euclidiana construída anteriormente.
$$inertia = \sum_{i=0}^{n}\min_{c_j \in C} (dist(x_i, c_j))^2$$
Can you write Python code for it?

def inertia(dataset, centroids, nearest_indexes):
    """
    Soma das distâncias quadradas das amostras para o
    centro do cluster mais próximo.

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]
    nearest_indexes -- Índices do centróides mais próximos - [m,1]

    Retornos:
    inertia -- Soma total do quadrado da distância entre
    os dados de um cluster e seu centróide
    """

    #### CODE HERE ####

    ### END OF CODE ###

    return inertia


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
1.4 Atualizar os clusters
Nessa etapa, os centróides são recomputados. O novo valor de cada centróide será a media de todos os dados atribuídos ao cluster.
Can you write Python code for it?

def update_centroids(dataset, centroids, nearest_indexes):
    """
    Atualiza os centroids

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]
    nearest_indexes -- Índices do centróides mais próximos - [m,1]

    Retornos:
    centroids -- Lista com centróides atualizados - [k,n]
    """

    #### CODE HERE ####

    ### END OF CODE ###

    return centroids


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
2. K-means
2.1 Algoritmo completo
Utilizando as funções codificadas anteriormente, complete a classe do algoritmo K-means!
Can you write Python code for it?

class KMeans():

    def __init__(self, n_clusters=8, max_iter=300):
        self.n_clusters = n_clusters
        self.max_iter = max_iter

    def fit(self,X):

        # Inicializa os centróides
        self.cluster_centers_ = [None]

        # Computa o cluster de cada amostra
        self.labels_ = [None]

        # Calcula a inércia inicial
        old_inertia = [None]

        for index in [None]:

            #### CODE HERE ####

            ### END OF CODE ###

        return self

    def predict(self, X):

        return [None]


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
2.2 Comparar com algoritmo do Scikit-Learn
Use a implementação do algoritmo do scikit-learn do K-means para o mesmo conjunto de dados. Mostre o valor da inércia  e os conjuntos gerados pelo modelo. Você pode usar a mesma estrutura da célula de código anterior.

Dica: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans
Can you write Python code for it?


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
3. Método do cotovelo
Implemete o método do cotovelo e mostre o melhor K para o conjunto de dados.
Can you write Python code for it?


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
Teste a função criada e visualize os centróides que foram calculados.
Can you write Python code for it?

k = 3
centroids = calculate_initial_centers(dataset, k)

plt.scatter(dataset[:,0], dataset[:,1], s=10)
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red',s=100)
plt.show()


I am working on the file "2019/09-clustering/Notebook_KMeans_Assignment.ipynb".
The first task is:
Teste a função criada.
Can you write Python code for it?

a = np.array([1, 5, 9])
b = np.array([3, 7, 8])

if (euclidean_distance(a,b) == 3):
    print("Distância calculada corretamente!")
else:
    print("Função de distância incorreta")


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
1. Implementar o algoritmo K-means
Nesta etapa você irá implementar as funções que compõe o algoritmo do KMeans uma a uma. É importante entender e ler a documentação de cada função, principalmente as dimensões dos dados esperados na saída.
1.1 Inicializar os centróides
A primeira etapa do algoritmo consiste em inicializar os centróides de maneira aleatória. Essa etapa é uma das mais importantes do algoritmo e uma boa inicialização pode diminuir bastante o tempo de convergência.
Para inicializar os centróides você pode considerar o conhecimento prévio sobre os dados, mesmo sem saber a quantidade de grupos ou sua distribuição.

Dica: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.uniform.html
Can you write Python code for it?

def calculate_initial_centers(dataset, k):
    """
    Inicializa os centróides iniciais de maneira arbitrária

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    k -- Número de centróides desejados

    Retornos:
    centroids -- Lista com os centróides calculados - [k,n]
    """

    #### CODE HERE ####
    m = dataset.shape[0]

    centroids = list(dataset[np.random.randint(0, m - 1, 1)])

    for it1 in range(k - 1):
        max_dist = -1

        for it2 in range(m):
            nrst_cent_dist = sys.float_info.max

            for it3 in range(len(centroids)):
                dist = np.linalg.norm(dataset[it2] - centroids[it3])
                # Get the distance to the nearest centroid
                if (dist < nrst_cent_dist):
                    nrst_cent_dist = dist
                    nrst_cent = dataset[it2]

            if (nrst_cent_dist > max_dist):
                max_dist = nrst_cent_dist
                new_cent = nrst_cent

        centroids.append(new_cent)

    centroids = np.array(centroids)
    ### END OF CODE ###

    return centroids


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
1.2 Definir os clusters
Na segunda etapa do algoritmo serão definidos o grupo de cada dado, de acordo com os centróides calculados.
1.2.1 Função de distância
Codifique a função de distância euclidiana entre dois pontos (a, b).
Definido pela equação:
$$ dist(a, b) = \sqrt{(a_1-b_1)^{2}+(a_2-b_2)^{2}+ ... + (a_n-b_n)^{2}} $$
$$ dist(a, b) = \sqrt{\sum_{i=1}^{n}(a_i-b_i)^{2}} $$
Can you write Python code for it?

def euclidean_distance(a, b):
    """
    Calcula a distância euclidiana entre os pontos a e b

    Argumentos:
    a -- Um ponto no espaço - [1,n]
    b -- Um ponto no espaço - [1,n]

    Retornos:
    distance -- Distância euclidiana entre os pontos
    """

    #### CODE HERE ####
    n = len(a)

    distance = 0
    for i in range(n):
        distance = distance + (a[i] - b[i])**2

    distance = distance**0.5
    ### END OF CODE ###

    return distance


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
3. Método do cotovelo
Implemete o método do cotovelo e mostre o melhor K para o conjunto de dados.
Can you write Python code for it?

#### CODE HERE ####

# Initialize array of Ks
ks = np.array(range(1, 11))
# Create array to receive the inertias for each K
inertias = np.zeros(len(ks))

for i in range(len(ks)):
    # Compute inertia for K
    kmeans = KMeans(ks[i]).fit(dataset)
    inertias[i] = kmeans.inertia_

    # Best K is the last one to improve the inertia in 30%
    if (i > 0 and (inertias[i - 1] - inertias[i])/inertias[i] > 0.3):
        best_k_idx = i

print("Best K: {}\n".format(ks[best_k_idx]))
plt.plot(ks, inertias, marker='o')
plt.plot(ks[best_k_idx], inertias[best_k_idx], 'ro')


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
Execute a função de atualização e visualize novamente os cluster formados
Can you write Python code for it?

centroids = update_centroids(dataset, centroids, nearest_indexes)


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
Teste a função codificada executando o código abaixo.
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
Teste a função criada e visualize os centróides que foram calculados.
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
Teste a função criada visualizando os cluster formados.
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
Verifique o resultado do algoritmo abaixo!
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_AlefCarneiro.ipynb".
The first task is:
Visualize os clusters formados
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_Franklyn.ipynb".
The first task is:
1.3 Métrica de avaliação
Após formar os clusters, como sabemos se o resultado gerado é bom? Para isso, precisamos definir uma métrica de avaliação.
O algoritmo K-means tem como objetivo escolher centróides que minimizem a soma quadrática das distância entre os dados de um cluster e seu centróide. Essa métrica é conhecida como inertia.
$$\sum_{i=0}^{n}\min_{c_j \in C}(||x_i - c_j||^2)$$
A inertia, ou o critério de soma dos quadrados dentro do cluster, pode ser reconhecido como uma medida de o quão internamente coerentes são os clusters, porém ela sofre de alguns inconvenientes:

A inertia pressupõe que os clusters são convexos e isotrópicos, o que nem sempre é o caso. Desta forma, pode não representar bem em aglomerados alongados ou variedades com formas irregulares.
A inertia não é uma métrica normalizada: sabemos apenas que valores mais baixos são melhores e zero é o valor ótimo. Mas em espaços de dimensões muito altas, as distâncias euclidianas tendem a se tornar infladas (este é um exemplo da chamada “maldição da dimensionalidade”). A execução de um algoritmo de redução de dimensionalidade, como o PCA, pode aliviar esse problema e acelerar os cálculos.

Fonte: https://scikit-learn.org/stable/modules/clustering.html
Para podermos avaliar os nosso clusters, codifique a métrica da inertia abaixo, para isso você pode utilizar a função de distância euclidiana construída anteriormente.
$$inertia = \sum_{i=0}^{n}\min_{c_j \in C} (dist(x_i, c_j))^2$$
Can you write Python code for it?

def inertia(dataset, centroids, nearest_indexes):
    """
    Soma das distâncias quadradas das amostras para o
    centro do cluster mais próximo.

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]
    nearest_indexes -- Índices do centróides mais próximos - [m,1]

    Retornos:
    inertia -- Soma total do quadrado da distância entre
    os dados de um cluster e seu centróide
    """

    #### CODE HERE ####
    vec = []
    for i in range(len(dataset)):
        vec.append(pow(euclidean_distance(dataset[i], centroids[nearest_indexes[i]]), 2))
    inertia = sum(vec)
    print(inertia)
    ### END OF CODE ###

    return inertia


I am working on the file "2019/09-clustering/cl_Franklyn.ipynb".
The first task is:
2.2 Comparar com algoritmo do Scikit-Learn
Use a implementação do algoritmo do scikit-learn do K-means para o mesmo conjunto de dados. Mostre o valor da inércia  e os conjuntos gerados pelo modelo. Você pode usar a mesma estrutura da célula de código anterior.

Dica: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_Franklyn.ipynb".
The first task is:
Execute a função de atualização e visualize novamente os cluster formados
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_Franklyn.ipynb".
The first task is:
Teste a função criada
Can you write Python code for it?

# Seleciona um ponto aleatório no dataset
index = np.random.randint(dataset.shape[0])
a = dataset[index,:]

# Usa a função para descobrir o centroid mais próximo
idx_nearest_centroid = nearest_centroid(a, centroids)

# Plota os dados ------------------------------------------------
plt.scatter(dataset[:,0], dataset[:,1], s=10)
# Plota o ponto aleatório escolhido em uma cor diferente
plt.scatter(a[0], a[1], c='magenta', s=30)

# Plota os centroids
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red', s=100)
# Plota o centroid mais próximo com uma cor diferente
plt.scatter(centroids[idx_nearest_centroid,0],
            centroids[idx_nearest_centroid,1],
            marker='^', c='springgreen', s=100)

# Cria uma linha do ponto escolhido para o centroid selecionado
plt.plot([a[0], centroids[idx_nearest_centroid,0]],
         [a[1], centroids[idx_nearest_centroid,1]],c='orange')
plt.annotate('CENTROID', (centroids[idx_nearest_centroid,0],
            centroids[idx_nearest_centroid,1],))
plt.show()


I am working on the file "2019/09-clustering/cl_Franklyn.ipynb".
The first task is:
Teste a função criada visualizando os cluster formados.
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_Franklyn.ipynb".
The first task is:
Teste a função criada.
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
1. Implementar o algoritmo K-means
Nesta etapa você irá implementar as funções que compõe o algoritmo do KMeans uma a uma. É importante entender e ler a documentação de cada função, principalmente as dimensões dos dados esperados na saída.
1.1 Inicializar os centróides
A primeira etapa do algoritmo consiste em inicializar os centróides de maneira aleatória. Essa etapa é uma das mais importantes do algoritmo e uma boa inicialização pode diminuir bastante o tempo de convergência.
Para inicializar os centróides você pode considerar o conhecimento prévio sobre os dados, mesmo sem saber a quantidade de grupos ou sua distribuição.

Dica: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.uniform.html
Can you write Python code for it?

def calculate_initial_centers(dataset, k):
    """
    Inicializa os centróides iniciais de maneira arbitrária

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    k -- Número de centróides desejados

    Retornos:
    centroids -- Lista com os centróides calculados - [k,n]
    """

    #### CODE HERE ####
    centroid = []
    c = 0
    while (c < k):
        x = np.array(np.random.uniform(min(dataset[:,0]),max(dataset[:,0])))
        y = np.array(np.random.uniform(min(dataset[:,1]),max(dataset[:,1])))
        centroid.append([x,y])
        c += 1

    centroids = np.array(centroid)
    ### END OF CODE ###

    return centroids


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
1.2 Definir os Clusters
Na segunda etapa do algoritmo serão definidos o grupo de cada dado, de acordo com os centróides calculados.
1.2.1 Função de distância
Codifique a função de distância euclidiana entre dois pontos (a, b).
Definido pela equação:
$$ dist(a, b) = \sqrt{(a_1-b_1)^{2}+(a_2-b_2)^{2}+ ... + (a_n-b_n)^{2}} $$
$$ dist(a, b) = \sqrt{\sum_{i=1}^{n}(a_i-b_i)^{2}} $$
Can you write Python code for it?

import math
def euclidean_distance(a, b):
    """
    Calcula a distância euclidiana entre os pontos a e b

    Argumentos:
    a -- Um ponto no espaço - [1,n]
    b -- Um ponto no espaço - [1,n]

    Retornos:
    distance -- Distância euclidiana entre os pontos
    """

    #### CODE HERE ####
    #s = 0
    #for i in range(len(a)):
    #    diff = (a[i] - b[i])
    #    s += diff*diff
    #distance = math.sqrt(s)
    #distance = math.sqrt(sum([((a[i] - b[i])**2) for i in range(len(a))]))

    distance = math.sqrt(sum((a-b)**2))

    ### END OF CODE ###

    return distance


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
1.2.2 Calcular o centroide mais próximo
Utilizando a função de distância codificada anteriormente, complete a função abaixo para calcular o centroid mais próximo de um ponto qualquer.

Dica: https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmin.html
Can you write Python code for it?

def nearest_centroid(a, centroids):
    """
    Calcula o índice do centroid mais próximo ao ponto a

    Argumentos:
    a -- Um ponto no espaço - [1,n]
    centroids -- Lista com os centróides - [k,n]

    Retornos:
    nearest_index -- Índice do centróide mais próximo
    """

    #### CODE HERE ####
    dist = float("inf")
    k = len(centroids)
    for i in range(k):
        d = euclidean_distance(a, centroids[i])
        if d < dist:
            nindex = i
            dist = d

    nearest_index = nindex
    ### END OF CODE ###

    return nearest_index


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
1.2.3 Calcular centroid mais próximo de cada dado do dataset
Utilizando a função anterior que retorna o índice do centroid mais próximo, calcule o centroid mais próximo de cada dado do dataset.
Can you write Python code for it?

def all_nearest_centroids(dataset, centroids):
    """
    Calcula o índice do centroid mais próximo para cada
    ponto do dataset

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]

    Retornos:
    nearest_indexes -- Índices do centróides mais próximos - [m,1]
    """

    #### CODE HERE ####
    nearest_indexes = [nearest_centroid(dataset[i], centroids) for i in range(len(dataset))]

    ### END OF CODE ###

    return nearest_indexes


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
1.3 Métrica de avaliação
Após formar os clusters, como sabemos se o resultado gerado é bom? Para isso, precisamos definir uma métrica de avaliação.
O algoritmo K-means tem como objetivo escolher centróides que minimizem a soma quadrática das distância entre os dados de um cluster e seu centróide. Essa métrica é conhecida como inertia.
$$\sum_{i=0}^{n}\min_{c_j \in C}(||x_i - c_j||^2)$$
A inertia, ou o critério de soma dos quadrados dentro do cluster, pode ser reconhecido como uma medida de o quão internamente coerentes são os clusters, porém ela sofre de alguns inconvenientes:

A inertia pressupõe que os clusters são convexos e isotrópicos, o que nem sempre é o caso. Desta forma, pode não representar bem em aglomerados alongados ou variedades com formas irregulares.
A inertia não é uma métrica normalizada: sabemos apenas que valores mais baixos são melhores e zero é o valor ótimo. Mas em espaços de dimensões muito altas, as distâncias euclidianas tendem a se tornar infladas (este é um exemplo da chamada “maldição da dimensionalidade”). A execução de um algoritmo de redução de dimensionalidade, como o PCA, pode aliviar esse problema e acelerar os cálculos.

Fonte: https://scikit-learn.org/stable/modules/clustering.html
Para podermos avaliar os nosso clusters, codifique a métrica da inertia abaixo, para isso você pode utilizar a função de distância euclidiana construída anteriormente.
$$inertia = \sum_{i=0}^{n}\min_{c_j \in C} (dist(x_i, c_j))^2$$
Can you write Python code for it?

def inertia(dataset, centroids, nearest_indexes):
    """
    Soma das distâncias quadradas das amostras para o
    centro do cluster mais próximo.

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    centroids -- Lista com os centróides - [k,n]
    nearest_indexes -- Índices do centróides mais próximos - [m,1]

    Retornos:
    inertia -- Soma total do quadrado da distância entre
    os dados de um cluster e seu centróide

        tmp_data = np.array([[1,2,3],[3,6,5],[4,5,6]])
        tmp_centroide = np.array([[2,3,4]])

        tmp_nearest_indexes = all_nearest_centroids(tmp_data, tmp_centroide)
        if inertia(tmp_data, tmp_centroide, tmp_nearest_indexes) == 26:
    """

    #### CODE HERE ####
    '''s = 0
    for i in range(len(tmp_data)):
        m = euclidean_distance(tmp_data[i],tmp_centroide[0])**2
        s += m'''

    inertia = sum([euclidean_distance(tmp_data[i],tmp_centroide[0])**2 for i in range(len(tmp_data))])
    ### END OF CODE ###

    return inertia


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
2. K-means
2.1 Algoritmo completo
Utilizando as funções codificadas anteriormente, complete a classe do algoritmo K-means!
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
2.2 Comparar com algoritmo do Scikit-Learn
Use a implementação do algoritmo do scikit-learn do K-means para o mesmo conjunto de dados. Mostre o valor da inércia  e os conjuntos gerados pelo modelo. Você pode usar a mesma estrutura da célula de código anterior.

Dica: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans
Can you write Python code for it?

#### CODE HERE ####
# fonte: https://stackabuse.com/k-means-clustering-with-scikit-learn/

import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

plt.scatter(dataset[:,0],dataset[:,1], label='True Position')

kmeans = KMeans(n_clusters=k)
kmeans.fit(dataset)
print("Inércia = ", kmeans.inertia_)
#print(kmeans.cluster_centers_)
#print(kmeans.labels_)

plt.scatter(dataset[:,0],dataset[:,1], c=kmeans.labels_, cmap='Set3')

plt.scatter(kmeans.cluster_centers_[:,0] ,kmeans.cluster_centers_[:,1], marker='^', color='black', s=100)


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
4. Dataset Real
Exercícios
1 - Aplique o algoritmo do K-means desenvolvido por você no datatse iris [1]. Mostre os resultados obtidos utilizando pelo menos duas métricas de avaliação de clusteres [2].

[1] http://archive.ics.uci.edu/ml/datasets/iris
[2] http://scikit-learn.org/stable/modules/clustering.html#clustering-evaluation

Dica: você pode utilizar as métricas completeness e homogeneity.

2 - Tente melhorar o resultado obtido na questão anterior utilizando uma técnica de mineração de dados. Explique a diferença obtida.

Dica: você pode tentar normalizar os dados [3].
- [3] https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.normalize.html

3 - Qual o número de clusteres (K) você escolheu na questão anterior? Desenvolva o Método do Cotovelo sem usar biblioteca e descubra o valor de K mais adequado. Após descobrir, utilize o valor obtido no algoritmo do K-means.
4 - Utilizando os resultados da questão anterior, refaça o cálculo das métricas e comente os resultados obtidos. Houve uma melhoria? Explique.
Can you write Python code for it?

#### CODE HERE ####
from sklearn import metrics

url="http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
data=pd.read_csv(url, header=None)

labels_true = [0, 0, 0, 1, 1, 1]
labels_pred = [0, 0, 1, 1, 2, 2]

metrics.homogeneity_score(labels_true, labels_pred)
metrics.completeness_score(labels_true, labels_pred)

#2

#3

#4


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Execute a função de atualização e visualize novamente os cluster formados
Can you write Python code for it?


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Teste a função codificada executando o código abaixo.
Can you write Python code for it?

tmp_data = np.array([[1,2,3],[3,6,5],[4,5,6]])
tmp_centroide = np.array([[2,3,4]])
tmp_nearest_indexes = all_nearest_centroids(tmp_data, tmp_centroide)

if inertia(tmp_data, tmp_centroide, tmp_nearest_indexes) == 26:
    print("Inertia calculada corretamente!")
else:
    print("Função de inertia incorreta!")

# Use a função para verificar a inertia dos seus clusters
inertia(dataset, centroids, nearest_indexes)


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Teste a função criada
Can you write Python code for it?

# Seleciona um ponto aleatório no dataset
index = np.random.randint(dataset.shape[0])
a = dataset[index,:]

# Usa a função para descobrir o centroid mais próximo
idx_nearest_centroid = nearest_centroid(a, centroids)

# Plota os dados ------------------------------------------------
plt.scatter(dataset[:,0], dataset[:,1], s=10)
# Plota o ponto aleatório escolhido em uma cor diferente
plt.scatter(a[0], a[1], c='magenta', s=30)

# Plota os centroids
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red', s=100)
# Plota o centroid mais próximo com uma cor diferente
plt.scatter(centroids[idx_nearest_centroid,0],
            centroids[idx_nearest_centroid,1],
            marker='^', c='springgreen', s=100)

# Cria uma linha do ponto escolhido para o centroid selecionado
plt.plot([a[0], centroids[idx_nearest_centroid,0]], [a[1], centroids[idx_nearest_centroid,1]], c='orange')
plt.annotate('CENTROID', (centroids[idx_nearest_centroid,0], centroids[idx_nearest_centroid,1],))
plt.show()


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Teste a função criada e visualize os centróides que foram calculados.
Can you write Python code for it?

k = 3
centroids = calculate_initial_centers(dataset, k)

plt.scatter(dataset[:,0], dataset[:,1], s=10)
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red',s=100)
plt.show()


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Teste a função criada visualizando os cluster formados.
Can you write Python code for it?

nearest_indexes = all_nearest_centroids(dataset, centroids)

plt.scatter(dataset[:,0], dataset[:,1], c=nearest_indexes)
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red', s=100)
plt.show()


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Teste a função criada.
Can you write Python code for it?

a = np.array([1, 5, 9])
b = np.array([3, 7, 8])

if (euclidean_distance(a,b) == 3):
    print("Distância calculada corretamente!")
else:
    print("Função de distância incorreta")


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Verifique o resultado do algoritmo abaixo!
Can you write Python code for it?

kmeans = KMeans(n_clusters=k)
kmeans.fit(dataset)

print("Inércia = ", kmeans.inertia_)

plt.scatter(dataset[:,0], dataset[:,1], c=kmeans.labels_)
plt.scatter(kmeans.cluster_centers_[:,0],
            kmeans.cluster_centers_[:,1], marker='^', c='red', s=100)
plt.show()


I am working on the file "2019/09-clustering/cl_Helio.ipynb".
The first task is:
Visualize os clusters formados
Can you write Python code for it?

nearest_indexes = all_nearest_centroids(dataset, centroids)

# Plota os os cluster ------------------------------------------------
plt.scatter(dataset[:,0], dataset[:,1], c=nearest_indexes)

# Plota os centroids
plt.scatter(centroids[:,0], centroids[:,1], marker='^', c='red', s=100)
for index, centroid in enumerate(centroids):
    dataframe = dataset[nearest_indexes == index,:]
    for data in dataframe:
        plt.plot([centroid[0], data[0]], [centroid[1], data[1]],
                 c='lightgray', alpha=0.3)
plt.show()


I am working on the file "2019/09-clustering/cl_JoãoCastelo.ipynb".
The first task is:
1. Implementar o algoritmo K-means
Nesta etapa você irá implementar as funções que compõe o algoritmo do KMeans uma a uma. É importante entender e ler a documentação de cada função, principalmente as dimensões dos dados esperados na saída.
1.1 Inicializar os centróides
A primeira etapa do algoritmo consiste em inicializar os centróides de maneira aleatória. Essa etapa é uma das mais importantes do algoritmo e uma boa inicialização pode diminuir bastante o tempo de convergência.
Para inicializar os centróides você pode considerar o conhecimento prévio sobre os dados, mesmo sem saber a quantidade de grupos ou sua distribuição.

Dica: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.uniform.html
Can you write Python code for it?

import random
def calculate_initial_centers(dataset, k):
    """
    Inicializa os centróides iniciais de maneira arbitrária

    Argumentos:
    dataset -- Conjunto de dados - [m,n]
    k -- Número de centróides desejados

    Retornos:
    centroids -- Lista com os centróides calculados - [k,n]
    """

    #### CODE HERE ####

    #coleta numero de colunas
    dimensoes = len(dataset[0])

    #coleta dos extremos das dimensoes
    extremos_dimensoes = []
    for i in range(0,dimensoes):
      maximo = max(dataset[: , i])
      minimo = min(dataset[: , i])

      extremos_dimensoes.append( {'max': maximo , 'min':  minimo} )

    centroids = []
    #fazendo os centroids
    for centro in range(0,k):

      posicao = []

      for n in range(0,dimensoes):

        posicao.append( random.uniform( extremos_dimensoes[n]['min'] , extremos_dimensoes[n]['max'] ) )

      centroids.append(posicao)

    ### END OF CODE ###

    return np.array(centroids)

calculate_initial_centers(dataset , 4)