I am working on the file "APS5_alunos.ipynb".
The first task is:
Explique o seu raciocínio
O cálculo da probabilidade nesse caso se baseia na análise dos casos que ocorrem no Norte em comparação com os casos totais de terremoto. Portanto para saber a probabilidade de ocorrer um terremoto no hemisfério Norte basta dividir esse valor, apresentado no crosstab, pela probabilidade total.
Q3.2 - Dado que aconteceu no Norte, qual a probabilidade de ele ter sido Nuclear Explosion?
Calcule a resposta abaixo, ou explique como a encontrou
Se for cálculo preencha a célula a seguir:
Can you write Python code for it?

probNuclear = ct["Nuclear Explosion"]["Norte"]/ct.All.Norte
print(probNuclear)


I am working on the file "APS5_alunos.ipynb".
The first task is:
Liste as primeiras linhas do DataFrame
Can you write Python code for it?


I am working on the file "APS5_alunos.ipynb".
The first task is:
Q1 - Manipulando o DataFrame
Crie uma coluna chamada Hemisfério baseada na Latitude
A regra de formação é a seguinte:
Valor | Critério
---|---
Norte | Latitude positiva
Sul | Latitude negativa
Can you write Python code for it?

df.loc[(df.Latitude >=0), "Hemisfério"] = "Norte"
df.loc[(df.Latitude <0), "Hemisfério"] = "Sul"
df.head()

df.Magnitude.describe()


I am working on the file "APS5_alunos.ipynb".
The first task is:
Q3.1 - Qual a probabilidade de ocorrer um terremoto no hemisfério norte?
Adicione na célula abaixo o cálculo:
Can you write Python code for it?

probNorte = ct.Earthquake.Norte/ct.Earthquake.All
print(probNorte)


I am working on the file "APS5_alunos.ipynb".
The first task is:
Q6 - Tirando conclusões com base nos dados
Em um certo lugar já ocorreram abalos com Magnitude Type MB e Type Nuclear Explosion.
Responda:
    * É mais provável que tenha sido no norte ou no sul?
Assuma que os Magnitude Type e Type são independentes
Can you write Python code for it?

df.loc[(df.Type=="Nuclear Explosion")&(df["Magnitude Type"]=="MB")&(df["Hemisfério"]=="Sul"),"Hemis"]="Sul"
df.loc[(df.Type=="Nuclear Explosion")&(df["Magnitude Type"]=="MB")&(df["Hemisfério"]=="Norte"),"Hemis"]="Norte"
sul=df["Hemis"].value_counts("Sul")
sul


I am working on the file "APS5_alunos.ipynb".
The first task is:
Se conseguir obter a resposta sem calcular, insira a resposta abaixo:

A probabilidade de ter sido Nuclear Explosion é ...

Q4 - Análise bivariada
Faça o plot de dispersão (scatter plot) entre as variáveis Magnitude Error  e Depth
Can you write Python code for it?

plt.scatter(x = df['Magnitude Error'],
            y = df['Depth'])
plt.show()


I am working on the file "APS8_ENTREGAFINAL.ipynb".
The first task is:
Q4
Faça uma regressão que usa sqft_living como variável explicativa  e price como resultado:
a). De acordo com a notação que usamos em aula, quem é $\hat{\beta_0}$ e quem é $\hat{\beta_1}$ ?
Can you write Python code for it?

y = houses.price
x = houses["sqft_living"]
x = sm.add_constant(x, prepend=True)
res = sm.OLS(y,x).fit()
res.summary()

c = 4.928e4
s = 247.0810
print("B0 = ",c)
print("B1 = ",s)


I am working on the file "APS8_ENTREGAFINAL.ipynb".
The first task is:
Q5
Faça agora uma regressão múltipla que tenta prever price (variável explicada) em função das variáveis sqft_lot  e sqft_basement (explicativa).
Dica: inclua as duas colunas dentro de uma variável X, o restante não se altera em relação à regressão simples.
python
Y = houses['price']
X = houses.loc[:, ['sqft_lot', 'sqft_basement']]
Pede-se:
a). Repita a intepretação dos valores $P > |t|$ e Prob (F-statistic) porém com duas variáveis.
O que os valores encontrados implicam para a regressão?
b). Escreva a função que foi encontrada pela regressão ( price em função de  sqft_lot  e sqft_basement)
Can you write Python code for it?

#a) O grau de influência entre uma variável e outra.

#b)

y = houses['price']
x = houses.loc[:, ['sqft_lot', 'sqft_basement']]
x = sm.add_constant(x, prepend=True)
res = sm.OLS(y,x).fit()
res.summary()

c = 5.237e05
s = 2.7668
B2 = 68.6891
y = c + s*houses["sqft_lot"] + B2*houses["sqft_basement"]
print(y)


I am working on the file "APS8_ENTREGAFINAL.ipynb".
The first task is:
b). Interprete o $R^2$ , os valores $P > |t|$ e também Prob (F-statistic).
Can you write Python code for it?

print("R^2 é oo grau de influência entre duas variáveis")
print("P>|t| é a probabilidade de duas variáveis não serem dependentes")


I am working on the file "APS8_QUESTOES.ipynb".
The first task is:
A partir da tabela sabe-se os valor de beta0 e beta1 e portanto:
Can you write Python code for it?

B0 = res.params.const
B1 = res.params.sqft_living
print("B0 é igual a: ")
print(B0)
print("B1 é igual a: ")
print(B1)


I am working on the file "APS8_QUESTOES.ipynb".
The first task is:
Pela distribuição dos pontos ao longo da reta, pode-se afirmar que não se trata de uma normal.
Caso a distribuição se tratasse de maneira normal, então poderia ser realizado um teste de hipótese para análise desta distribuição.
O valor de σ não seria conhecido, apesar de ser possível encontrar um valor aproximado deste, por outro lado o valor de μ seria conhecido e poderia ser prontamente utilizado para avaliação da distribuição normal.
Can you write Python code for it?

am = []
for i in houses.sqft_lot:
    am.append(i)
al = 0.05
n = len(am)
s = np.std(am, ddof=1)
m_ = np.mean(am)
l = []
for i in range(10000):
    #valor aleatório para toda a porcentagem que se deseja analisar o bootsrap
    a = np.random.choice(am,size = n, replace = True).mean()
    l.append(a)
#Valores Máximo e Mínimo do boostrap criado
print("Valor mínimo igual a: ")
print(pd.Series(l).quantile(al/2))
print("Valor Máximo igual a: ")
print(pd.Series(l).quantile(1-(al/2)))


I am working on the file "APS8_QUESTOES.ipynb".
The first task is:
Q4
Faça uma regressão que usa sqft_living como variável explicativa  e price como resultado:
a). De acordo com a notação que usamos em aula, quem é $\hat{\beta_0}$ e quem é $\hat{\beta_1}$ ?
Can you write Python code for it?

hp = houses.price
hl = houses["sqft_living"]
hl = sm.add_constant(hl, prepend=True)
res = sm.OLS(hp,hl).fit()
res.summary()


I am working on the file "APS8_QUESTOES.ipynb".
The first task is:
b). Interprete o $R^2$ , os valores $P > |t|$ e também Prob (F-statistic).
O valor de R² é basicamente a demonstração numérica de quanto o modelo é capaz de os valores, ou seja uma espécie de ajuste do mesmo. Enquanto o P>|t|é apenas o calculo da probabilidade de que não existe relação ou influência entre variáveis determinadas.
c) Escreva a equação que expressa price em função de sqft_living.
Can you write Python code for it?

print("House.price = {0} + {1} hl, sendo hp o preço e hl o sqft_living, ou seja tamanho do interior habitável da casa".format(B0,B1))


I am working on the file "APScheduler and PyMongo.ipynb".
The first task is:
The following can be run while the kernal is still running and adding prices to the collection but will need to be done outside of ipython notebook. I also have spyder installed and was able to run "for price in bitcoin.find(): print price"
Below we convert the collection to a pandas dataframe and then make a plot of the price movement.
Can you write Python code for it?

import pandas as pd
import matplotlib.pyplot as plt
%pylab inline

bitcoin_df =  pd.DataFrame(list(bitcoin.find()))
bitcoin_df.head()

len(bitcoin_df)

plt.plot(bitcoin_df['price'])


I am working on the file "APScheduler and PyMongo.ipynb".
The first task is:
There are many different types of schedulers, with BlockingScheduler being described as the easiest to use. Using add_job() we add the function that we want called tell it that it will be called a intervals of 1 minute. There are many other ways the function can be called and can be found in the documents.
I let this block run for a few minutes and then pressed the stop button to interupt the kernel.
Can you write Python code for it?

bitcoin.remove({}) #Added to empty out the collection the first time the code is run

scheduler = BlockingScheduler()
scheduler.add_job(get_price, 'interval', minutes=1)

try:
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    pass


I am working on the file "APTest/DR12Q_correl_AP_MI_fast-cdist-DR.ipynb".
The first task is:
Read the data file (taken from http://cosmo.nyu.edu/~eak306/SDSS-LRG.html ) converted to ascii with comoving distance etc. in V01 reading from pkl files for faster read
Can you write Python code for it?

# Getting back the objects:
with open('../output/randDR12Qbin2.pkl') as f:  # Python 3: open(..., 'rb')
    datR = pickle.load(f)
datR

dr2d=np.zeros((20,20))

%%time
dist0=d.cdist([dat[0],],datR,APdz)[0]
dist1=d.cdist([dat[0],],datR,APzdth)[0]
print np.histogram2d(dist0, dist1,bins=20, range=rng)

%%time
for i in tqdm(xrange(len(dat))):
    dist0=d.cdist([dat[i],],datR,APdz)[0]
    dist1=d.cdist([dat[i],],datR,APzdth)[0]
    dr2d+=np.histogram2d(dist0, dist1, bins=20,range=rng)[0]
print dr2d

with open('DR12QDRbin2.pkl','w') as f:
    pickle.dump(dr2d,f)
dr2d

# Getting back the objects:
with open('../output/DR12Qbin3.pkl') as f:  # Python 3: open(..., 'rb')
    dat = pickle.load(f)
dat


# Getting back the objects:
with open('../output/randDR12Qbin1.pkl') as f:  # Python 3: open(..., 'rb')
    datR = pickle.load(f)
datR

dr2d=np.zeros((20,20))

rng = np.array([[0, 0.02], [0, 0.02]])

%%time
dist0=d.cdist([dat[0],],datR,APdz)[0]
dist1=d.cdist([dat[0],],datR,APzdth)[0]
print np.histogram2d(dist0, dist1,bins=20, range=rng)

%%time
for i in tqdm(xrange(len(dat))):
    dist0=d.cdist([dat[i],],datR,APdz)[0]
    dist1=d.cdist([dat[i],],datR,APzdth)[0]
    dr2d+=np.histogram2d(dist0, dist1, bins=20,range=rng)[0]
print dr2d

with open('DR12QDRbin1.pkl','w') as f:
    pickle.dump(dr2d,f)
dr2d

# Getting back the objects:
with open('../output/DR12Qbin2.pkl') as f:  # Python 3: open(..., 'rb')
    dat = pickle.load(f)
dat


I am working on the file "ARCC+Bootcamp+Machine+Learning.ipynb".
The first task is:
Basic workflow when using Machine Learning algorithms

Neural Networks
Neural Networks can be thought of as a one large composite function, which is comprised of other functions. Each layer is a function that is fed an input which is the result of the previous function's output.
For example:

The example above was rather rudimentary. Let us look at a case where we have more than one inputs, fed to a prediction function that maps them to an output. This can be depicted by the following graph.

Building a Neural Network
The function carried out by our layer is termed as the sigmoid. It takes the form: $1/(1+exp(-x))$
Steps to follow to create our neural network:

1) Get set of input

2) dot with a set of weights i.e. weight1input1+weight2input2+weight3*input3

3) send the dot product to our prediction function i.e. sigmoid

4) check how much we missed i.e. calculate error

5) adjust weights accordingly

6) Do this for all inputs and about 1000 times
Can you write Python code for it?

#import numpy library
import numpy as np

# Sigmoid function which maps any value to between 0 and 1
# This is the function which will our layers will comprise of
# It is used to convert numbers to probabilties

def sigmoid(x):
    return 1/(1+np.exp(-x))

# input dataset
# 4 set of inputs
x = np.array([[0.45,0,0.21],[0.5,0.32,0.21],[0.6,0.5,0.19],[0.7,0.9,0.19]])

# output dataset corresponding to our set of inputs
# .T takes the transpose of the 1x4 matrix which will give us a 4x1 matrix
y = np.array([[0.5,0.4,0.6,0.9]]).T

#Makes our model deterministic for us to judge the outputs better
#Numbers will be randomly distributed but randomly distributed in exactly the same way each time the model is trained
np.random.seed(1)

# initialize weights randomly with mean 0, weights lie within -1 to 1
# dimensions are 3x1 because we have three inputs and one output
weights = 2*np.random.random((3,1))-1

#Network training code
#Train our neural network
for iter in range(1000):
    #get input
    input_var = x

    #This is our prediction step
    #first predict given input, then study how it performs and adjust to get better
    #This line first multiplies the input by the weights and then passes it to the sigmoid function
    output = sigmoid(np.dot(input_var,weights))

    #now we have guessed an output based on the provided input
    #subtract from the actual answer to see how much did we miss
    error = y - output

    #based on error update our weights
    weights += np.dot(input_var.T,error)

#The best fit weights by our neural net is as following:
print("The weights that the neural network found was:")
print(weights)

#Predict with new inputs i.e. dot with weights and then send to our prediction function
predicted_output = sigmoid(np.dot(np.array([0.3,0.9,0.1]),weights))
print ("Predicted Output:")
print (predicted_output)


I am working on the file "ARCC+Bootcamp+Machine+Learning.ipynb".
The first task is:
Support Vector Machines
“Support Vector Machine” (SVM) is a supervised machine learning algorithm which can be used for both classification or regression challenges. However, it is mostly used in classification problems. An example of SVM would be using a linear hyperplane to seperate two clusters of data points. The following code implements the same.
Can you write Python code for it?

#import basic libraries for plotting and scientific computing
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import style
#emulates the aesthetics of ggplot in R
style.use("ggplot")

#import class svm from scikit-learn
from sklearn import svm

#input data
X = [1, 5, 1.5, 8, 1, 9]
Y = [2, 8, 1.8, 8, 0.6, 11]

#classes assigned to input data
y = [0,1,0,1,0,1]

#plot input data
#plt.scatter(X,Y)
#plt.show()

#Create the Linear Support Vector Classification
clf = svm.SVC(kernel='linear', C = 1.0)

#input data in 2-D
points=[[1,2],[5,8],[1.5,1.8],[8,8],[1,0.6],[9,11]]#,[2,2],[1,4]]

#Fit the data with Linear Support Vector Classification
clf.fit(points,y) #Fit is a synonym for "find patterns in data"

#Predict the class for the following two points depending on which side of the SVM they lie
print(clf.predict([0.58,0.76]))
print(clf.predict([10.58,10.76]))

#find coefficients of the linear svm
w = clf.coef_[0]
#print(w)

#find slope of the line we wish to draw between the two classes
#a=change in y/change in x
a = -w[0] / w[1]

#Draw the line

#x points for a line
#linspace ->Return evenly spaced numbers over a specified interval.
xx = np.linspace(0,12)
#equation our SVM hyperplane
yy = a * xx - clf.intercept_[0] / w[1]

#plot the hyperplane
h0 = plt.plot(xx, yy, 'k-', label="svm")
#plot the data points as a scatter plot
plt.scatter(X,Y)
plt.legend()
plt.show()


I am working on the file "ARIMA/ShampooSales.ipynb".
The first task is:
p: The number of lag observations included in the model, also called the lag order.
d: The number of times that the raw observations are differenced, also called the degree of differencing.
q: The size of the moving average window, also called the order of moving average.
Can you write Python code for it?

#fit entire model
model = ARIMA(series, order=(5,1,0))

model_fit = model.fit(disp=0)

model_fit.summary()

residuals = DataFrame(model_fit.resid)

residuals.plot()
plt.show()

residuals.plot(kind='kde')
plt.show()

residuals.describe()


I am working on the file "ARIMA_Predictor.ipynb".
The first task is:
4. How to build the ARIMA Model
Can you write Python code for it?

model = ARIMA(wwwus.value, order=(1,1,2))
model_fit = model.fit(disp=0)
print('first fit ',model_fit.summary())


I am working on the file "ARIMA_Predictor.ipynb".
The first task is:
6. Plot Predict Actual vs Fitted
When you set dynamic=False in-sample lagged values are used for prediction.
That is, the model gets trained up until the previous values to make next prediction. This can make a fitted forecast and actuals look artificially good.
Can you write Python code for it?

plt.rcParams.update({'figure.figsize':(9,3), 'figure.dpi':120})
model_fit.plot_predict(dynamic=False)
plt.show()


I am working on the file "ARIMA_Predictor.ipynb".
The first task is:
8. Some scores and performance
The 20 observations depends on the train/test set fc,se,conf = fitted.forecast(20, alpha=0.05)  # 95% conf
Can you write Python code for it?

print(forecast_accuracy(fc, test.values))

print('Around 5% MAPE implies a model is about 95% accurate in predicting next 20 observations.')


I am working on the file "ARIMA_Predictor.ipynb".
The first task is:
A p-value less than 0.05 (typically ≤ 0.05) is statistically significant. It indicates strong evidence against the null hypothesis, as there is less than a 5% probability the null hypo is correct (and the results are by random). Therefore, we reject the null hypothesis, and accept the alternative hypothesis (there is  correlation).
Our timeserie is not significant, why?
Example:
ADF Statistic: -2.464240
p-value: 0.124419
0-Hypothesis non stationary
0.12 > 0.05 -> not significant, therefore we can not reject the 0-hypthesis so our time series is non stationary and we had to differencing it to make it stationary.
The purpose of differencing it is to make the time series stationary.
Can you write Python code for it?

# Original Series
fig, axes = plt.subplots(3, 2, sharex=True)
axes[0, 0].plot(wwwus.value); axes[0, 0].set_title('Orig Series')
plot_acf(wwwus.value, ax=axes[0, 1], lags=60)

# 1st Differencing
axes[1, 0].plot(wwwus.value.diff()); axes[1, 0].set_title('1st Order Differencing')
plot_acf(wwwus.value.diff().dropna(), ax=axes[1, 1], lags=60)

# 2nd Differencing
axes[2, 0].plot(wwwus.value.diff().diff()); axes[2, 0].set_title('2nd Order Differencing')
plot_acf(wwwus.value.diff().diff().dropna(), ax=axes[2, 1], lags=60)

plt.show()


I am working on the file "ARIMA_Predictor.ipynb".
The first task is:
For the above series, the time series reaches stationarity with two orders of differencing. But we use for the beginning 1 order as a conservative part. Let me explain that:
D>2 is not allowed in statsmodels.tsa.arima_model!
Maybe d>2 is not allowed means our best bet is to start simple, check if integrating once grants stationarity. If so, we can fit a simple ARIMA model and examine the ACF of the residual values to get a better feel about what orders of differencing to use. Also a drawback, if we integrate more than two times (d>2), we lose n observations, one for each integration. And one of the most common errors in ARIMA modeling is to "overdifference" the series and end up adding extra AR or MA terms to undo the forecast damage, so the author (I assume) decides to raise this exception.
#2. How to find the order of the AR term (p)
Can you write Python code for it?

plt.rcParams.update({'figure.figsize':(9,3), 'figure.dpi':120})
fig, axes = plt.subplots(1, 2, sharex=True)
axes[0].plot(wwwus.value.diff()); axes[0].set_title('1st Differencing')
axes[1].set(ylim=(0,5))
plot_pacf(wwwus.value.diff().dropna(), ax=axes[1], lags=100)

plt.show()


I am working on the file "ARIMA_Predictor.ipynb".
The first task is:
Notice here the coefficient of the MA2 term is close to zero (-0.0010 ) and the P-Value in ‘P>|z|’ column is highly insignificant (0.9). It should ideally be less than 0.05 for the respective X to be significant << 0.05.
5. Plot residual errors
Can you write Python code for it?

residuals = pd.DataFrame(model_fit.resid)
plt.rcParams.update({'figure.figsize':(9,3), 'figure.dpi':120})
fig, ax = plt.subplots(1,2)
residuals.plot(title="Residuals", ax=ax[0])
residuals.plot(kind='kde', title='Density', ax=ax[1])
plt.show()


I am working on the file "ARIMA_Predictor.ipynb".
The first task is:
Step by Step Code Order
#1. How to find the order of differencing (d) in ARIMA model

p is the order of the AR term

q is the order of the MA term

d is the number of differencing required to make the time series stationary as I term
Can you write Python code for it?

#1. How to find the order of differencing (d) in ARIMA model
result = adfuller(wwwus.value.dropna())
print('ADF Statistic: %f' % result[0])
print('p-value: %f' % result[1])


I am working on the file "ARIMA_Predictor2.ipynb".
The first task is:
#3. How to find the order of the MA term (q)
Can you write Python code for it?

fig, axes = plt.subplots(1, 2, sharex=True)
axes[0].plot(wwwus.value.diff()); axes[0].set_title('1st Differencing')
axes[1].set(ylim=(0,1.2))
plot_acf(wwwus.value.diff().dropna(), ax=axes[1] , lags=90)

plt.show()


I am working on the file "ARIMA_Predictor2.ipynb".
The first task is:
4. How to build the ARIMA Model
Can you write Python code for it?


I am working on the file "ARIMA_Predictor2.ipynb".
The first task is:
7. Now Create Training and Test Validation
We can see that ARIMA is adequately forecasting the seasonal pattern in the series. In terms of the model performance, the RMSE (root mean squared error) and MFE (mean forecast error) and also best in terms of the lowest BIC .
Can you write Python code for it?

train = wwwus.value[:80]
test = wwwus.value[80:]

#model = ARIMA(train, order=(3, 2, 1))
model = ARIMA(train, order=(2, 2, 3))
fitted = model.fit(disp=-1)
print('second fit ',fitted.summary())

# Forecast
fc,se,conf = fitted.forecast(20, alpha=0.05)  # 95% conf

# Make as pandas series
fc_series = pd.Series(fc, index=test.index)
lower_series = pd.Series(conf[:,0], index=test.index)
upper_series = pd.Series(conf[:,1], index=test.index)

# Plot
plt.figure(figsize=(12,5), dpi=100)
plt.plot(train, label='training')
plt.plot(test, label='actual')
plt.plot(fc_series, label='forecast')
plt.fill_between(lower_series.index, lower_series, upper_series,
                                            color='k', alpha=.15)
plt.title('maXbox4 Forecast vs Actuals ARIMA')
plt.legend(loc='upper left', fontsize=8)
plt.show()


I am working on the file "ARIMA_Predictor2.ipynb".
The first task is:
A p-value less than 0.05 (typically ≤ 0.05) is statistically significant. It indicates strong evidence against the null hypothesis, as there is less than a 5% probability the null hypo is correct (and the results are by random). Therefore, we reject the null hypothesis, and accept the alternative hypothesis (there is  correlation).
Our timeserie is not significant, why?
Example:
ADF Statistic: -2.464240
p-value: 0.124419
0-Hypothesis non stationary
0.12 > 0.05 -> not significant, therefore we can not reject the 0-hypthesis so our time series is non stationary and we had to differencing it to make it stationary.
The purpose of differencing it is to make the time series stationary.
Can you write Python code for it?


I am working on the file "ARIMA_Predictor2.ipynb".
The first task is:
For the above series, the time series reaches stationarity with two orders of differencing. But we use for the beginning 1 order as a conservative part. Let me explain that:
D>2 is not allowed in statsmodels.tsa.arima_model!
Maybe d>2 is not allowed means our best bet is to start simple, check if integrating once grants stationarity. If so, we can fit a simple ARIMA model and examine the ACF of the residual values to get a better feel about what orders of differencing to use. Also a drawback, if we integrate more than two times (d>2), we lose n observations, one for each integration. And one of the most common errors in ARIMA modeling is to "overdifference" the series and end up adding extra AR or MA terms to undo the forecast damage, so the author (I assume) decides to raise this exception.
#2. How to find the order of the AR term (p)
Can you write Python code for it?


I am working on the file "ARIMA_Predictor21.ipynb".
The first task is:
4. How to build the ARIMA Model
Can you write Python code for it?


I am working on the file "ARIMA_Predictor21.ipynb".
The first task is:
6. Plot Predict Actual vs Fitted
When you set dynamic=False in-sample lagged values are used for prediction.
That is, the model gets trained up until the previous values to make next prediction. This can make a fitted forecast and actuals look artificially good.
Can you write Python code for it?


I am working on the file "ARIMA_Predictor21.ipynb".
The first task is:
7. Now Create Training and Test Validation
We can see that ARIMA is adequately forecasting the seasonal pattern in the series. In terms of the model performance, the RMSE (root mean squared error) and MFE (mean forecast error) and also best in terms of the lowest BIC .
Can you write Python code for it?


I am working on the file "ARIMA_Predictor21.ipynb".
The first task is:
8. Some scores and performance
The 20 observations depends on the train/test set fc,se,conf = fitted.forecast(20, alpha=0.05)  # 95% conf
Can you write Python code for it?


I am working on the file "ARIMA_Predictor21.ipynb".
The first task is:
For the above series, the time series reaches stationarity with two orders of differencing. But we use for the beginning 1 order as a conservative part. Let me explain that:
D>2 is not allowed in statsmodels.tsa.arima_model!
Maybe d>2 is not allowed means our best bet is to start simple, check if integrating once grants stationarity. If so, we can fit a simple ARIMA model and examine the ACF of the residual values to get a better feel about what orders of differencing to use. Also a drawback, if we integrate more than two times (d>2), we lose n observations, one for each integration. And one of the most common errors in ARIMA modeling is to "overdifference" the series and end up adding extra AR or MA terms to undo the forecast damage, so the author (I assume) decides to raise this exception.
#2. How to find the order of the AR term (p)
Can you write Python code for it?


I am working on the file "ARIMA_Predictor21.ipynb".
The first task is:
Notice here the coefficient of the MA2 term is close to zero (-0.0010 ) and the P-Value in ‘P>|z|’ column is highly insignificant (0.9). It should ideally be less than 0.05 for the respective X to be significant << 0.05.
5. Plot residual errors
Let’s plot the residuals to ensure there are no patterns (that is, look for constant mean and variance).
Can you write Python code for it?


I am working on the file "ARIMAmodel_BaselineFinal.ipynb".
The first task is:
Convert back to the original levels scale and get model score
We reconvert predictions in differences into the original scale and capture the ARIMA model's predictive scores:
Can you write Python code for it?

raw_preds = pd.Series(results_ARIMA.fittedvalues, copy= True)
sum_preds = raw_preds.cumsum()
pred = pd.Series(df.ix[0], index=df.index)
pred = pred.add(sum_preds, fill_value=0)

from sklearn.linear_model import LinearRegression as LR
x = np.asarray(pred).reshape(len(df), 1)
y = np.asarray(df).reshape(len(df), 1)
lr = LR().fit(x, y)
a = lr.score(x, y)

print 'ARIMA predictions:'
plt.figure(figsize = (15,5))
plt.plot(df)
plt.plot(pred, color = 'r')
plt.title('CCI: Actual vs. ARIMA Prediction \n R$^2$ = {}'.format(a))
plt.tight_layout()
plt.show()


I am working on the file "ARIMAmodel_BaselineFinal.ipynb".
The first task is:
Estimating our ARIMA baseline model
Following the arguments on economic forecasting outlined in Stock (2001), we first set out to assess which is the most adequate model that can be built to predict the Consumer Confidence Index (CCI) using only information about its lagged values. This model, Stock argues, should be the working baseline to which the predictive power of any new model considering external data should be compared.
In the Notebook below, we present a time series analysis of the CCI, considering whether it follows a random walk process, and studying the evolution of its stationary changes as a function of its own autoregressive and moving-average regressors. For this purpose, we discuss the optimal parameters of an ARIMA model without exogenous regressors.
Summary of Key Results:

Our best model for predicting CCI is an ARIMA model with AR(2), MA(3) and I(1).
The in-sample R$^2$ of this model is 98.5%
The Roll-forward R$^2$ of this model on the last year of CCI data is 35.6%

Visualize data
Can you write Python code for it?

fig = plt.figure(figsize = (15, 15))

ax1 = fig.add_subplot(2, 1, 1)
ax1 = plt.plot(df)
ax1 = plt.title('Consumer Confidence Index \n Monthly Score')
ax1 = plt.xlabel('Date')
ax1 = plt.ylabel('CCI')

ax1 = fig.add_subplot(2, 1, 2)
ax1 = plt.plot(df.diff())
ax1 = plt.title('Consumer Confidence Index \n Monthly Score Difference')
ax1 = plt.xlabel('Date')
ax1 = plt.ylabel('CCI')

plt.show()


I am working on the file "ARIMAmodel_BaselineFinal.ipynb".
The first task is:
Of these three specifications, the ARIMA model which incorporates both autoregressive (p=2) and moving average (q=3) regressors yields the lowest RSS scores. Hence, we continue to work with this specification.
Can you write Python code for it?

print 'Results summary table for the ARIMA model:'
results_ARIMA.summary2()


I am working on the file "ARIMAmodel_BaselineFinal.ipynb".
The first task is:
The Dickey-Fuller Test, under different specifications, suggest that we can confidently reject its null hypothesis that the CCI (in differences) follows a random walk. For this reason, we proceed to predict the CCI in differences as a function of its autoregressive and moving-average lags.
Estimating Parameters for the ARIMA model
Can you write Python code for it?

from statsmodels.tsa.stattools import acf, pacf
diff_acf = acf(diff, nlags = 20)
diff_pacf = pacf(diff, nlags = 20, method = 'ols')

plt.figure(figsize=(15, 5))

plt.subplot(121)
plt.plot(diff_acf)
plt.xlabel('Number of lags')
plt.ylabel('Correlation')
plt.axhline(y=0,linestyle='--',color='gray')
plt.axhline(y=-1.96/np.sqrt(len(diff)),linestyle='--',color='gray')
plt.axhline(y=1.96/np.sqrt(len(diff)),linestyle='--',color='gray')
plt.title('Autocorrelation Function')
plt.axvline(3)

plt.subplot(122)
plt.plot(diff_pacf)
plt.xlabel('Number of lags')
plt.ylabel('Partial Correlation')
plt.axhline(y=0,linestyle='--',color='gray')
plt.axhline(y=-1.96/np.sqrt(len(diff)),linestyle='--',color='gray')
plt.axhline(y=1.96/np.sqrt(len(diff)),linestyle='--',color='gray')
plt.title('Partial Autocorrelation Function')
plt.axvline(2)

plt.tight_layout()
plt.show()


I am working on the file "ARIMAmodel_BaselineFinal.ipynb".
The first task is:
The Dickey-Fuller Test, under different specifications, suggest that we cannot reject its null hypothesis that the CCI follows a random walk. For this reason, we now test the stationarity of the CCI in differences of one month.
Test stationarity of CCI in differences
Can you write Python code for it?

diff = df.diff()
diff.dropna(inplace=True)
print 'Tests of stationarity on CCI (in differences)'
test_stationarity(diff)


I am working on the file "ASGP.ipynb".
The first task is:
From the left panel in this figure it is clear that there is a single active subspace.
From the right panel we see that it is the second dimension.
Figure 5
In this example we modify the function used to produce figure 4 by multiplying it by $x_1$ and $x_2$. This effectively makes the function have a 3 dimensional active subspace.
This example is slightly different than what S&B present in that I plot the maximum absolute error on the 1,000 random testing points instead of what they refer to as the average error.
Can you write Python code for it?

def f5(x):
    return x[1]*x[2] * f4(x)

def df5(x):
    _f4 = f4(x)
    val = np.atleast_1d(x[1] * x[2] * _f4)
    coefs = np.array([0.01, 0.7, 0.02, 0.03, 0.04, 0.05, 0.06, 0.08, 0.09, 0.1])
    out = val[:, None] * coefs[None, :]
    out[:, 1] += x[2] * _f4
    out[:, 2] += x[1] * _f4
    return out

def figure5():
    np.random.seed(42)
    Nvals = np.array([10, 30, 100, 250, 500, 1000])
    num_Ns = len(Nvals)
    max_errs = np.inf * np.ones((num_Ns, 3))
    max_errs_gp = np.inf * np.ones(num_Ns)

    # construct test points
    X_test = randOmega(1000, 10)
    f_test = f5(X_test.T)

    for i, N in enumerate(Nvals):
        # training points
        X = randOmega(int(N), 10)
        V = f5(X.T)
        G = df5(X.T)

        CN = (G.T @ G) / N
        vals, vecs = linalg.eigh(CN)
        for d in range(3, 0, -1):

            # find active subspace of dimension d
            W = vecs[:, -d:]
            Y = X @ W

            # fit GP on active subspace
            gp_as = GaussianProcessRegressor(RBF(), n_restarts_optimizer=0)
            gp_as.fit(Y.reshape(N, d), V)
            m_tilde = gp_as.predict((X_test @ W).reshape(1000, d))
            max_errs[i, d-1] = np.max(np.abs(f_test - m_tilde))

        gp = GaussianProcessRegressor(RBF())
        gp.fit(X, V)
        m_tilde = gp.predict(X_test)
        max_errs_gp[i] = np.max(np.abs(f_test - m_tilde))

    fig, ax = plt.subplots(1, 2, figsize=(9, 5))
    x = np.arange(1, 11)
    ax[0].semilogy(x, vals, ".", ms=15)
    ax[0].set_xlabel("Sorted eigenvalues")
    ax[0].set_xticks(x)
    ax[0].set_ylabel("$\lambda$")

    ax[1].semilogy(Nvals, max_errs, ".-", ms=15)
    ax[1].semilogy(Nvals, max_errs_gp, ".-", ms=15)
    ax[1].legend([str(i) + "d AS" for i in range(1, 4)] + ["Full GP"])
    ax[1].set_xlabel("# of points")

    fig.tight_layout()
    return fig, max_errs

fig5, max_errs = figure5();


I am working on the file "ASGP.ipynb".
The first task is:
I will be evaluating this function on points in $\Omega \equiv [-1, 1]^2$
Can you write Python code for it?

def randOmega(N, D=2):
    "random points on Ωᴰ := [-1, 1]ᴰ"
    return 2 * (np.random.rand(N, D) - 0.5)

def figure3():
    np.random.seed(43)
    Nvals = np.array([4, 8, 16, 32])
    num_Ns = len(Nvals)
    ave_errs_as = np.inf * np.ones(num_Ns)
    ave_errs = np.inf * np.ones(num_Ns)

    # construct test points
    X_test = randOmega(1000, 2)
    f1_test = f3(X_test.T)

    for i, N in enumerate(Nvals):
        # training points
        X = randOmega(N, 2)
        V = f3(X.T)
        G = df3(X.T)

        # find active subspace
        CN = (G.T @ G) / N
        vals, vecs = linalg.eigh(CN)
        W = vecs[:, 1]
        Y = X @ W

        # fit GP on active subspace
        gp_as = GaussianProcessRegressor(RBF())
        gp_as.fit(Y[:, None], V)
        m_tilde_as = gp_as.predict((X_test @ W)[:, None])
        ave_errs_as[i] = np.sqrt(np.sum((f1_test - m_tilde_as)**2 / (f1_test**2)) / N)

        # fit gp on input domain
        gp_as = GaussianProcessRegressor(RBF())
        gp_as.fit(X, V)
        m_tilde = gp_as.predict(X_test)
        ave_errs[i] = np.sqrt(np.sum((f1_test - m_tilde)**2 / (f1_test**2)) / N)

    fig, ax = plt.subplots(1, 2, figsize=(9, 5))
    ax[0].plot([1, 2], W, ".", ms=15)
    ax[0].set_xlabel("Input dimension")
    ax[0].set_xticks([1, 2])
    ax[0].set_ylabel("Magnitude of W")

    ax[1].semilogy(Nvals, ave_errs_as, ".-", label="ASGP", ms=15)
    ax[1].semilogy(Nvals, ave_errs, ".-", label="GP", ms=15)
    ax[1].legend()
    fig.tight_layout()
    return fig

figure3();


I am working on the file "ASGP.ipynb".
The first task is:
Notice that the coefficient on the second component of $x$ is an order of magnitude larger than all the other coefficients, so the value of the second component will largely drive the value of $f4$.
This means we should expect to see a 1 dimensional active subspace.
To verify if our intuition is correct, we will plot both the set of eigenvalues of the matrix $C_N$ as well as the principal eigenvector of $C_N$.
Can you write Python code for it?

def figure4():
    np.random.seed(41)
    N = 300
    X = randOmega(N, 10)
    V = f4(X.T)
    G = df4(X.T)
    CN = (G.T @ G) / N

    # find active subspace
    vals, vecs = linalg.eigh(CN)
    W = vecs[:, -1]

    fig, ax = plt.subplots(1, 2, figsize=(9, 5))
    x = np.arange(1, 11)
    ax[0].plot(x, vals, ".", ms=15)
    ax[0].set_xlabel("Sorted eigenvalues")
    ax[0].set_xticks(x)
    ax[0].set_ylabel("$\lambda$")

    ax[1].plot(x, W, ".", ms=15)
    ax[1].set_xlabel("Input dimension")
    ax[1].set_xticks(x)
    ax[1].set_ylabel("Magnitude of W")

    fig.tight_layout()
    return fig

figure4();


I am working on the file "ASGP.ipynb".
The first task is:
Somewhat surprisingly the GPR is more accurate on the 1-dimensional active subspace instead of the 2-dimensional input space. I'm not 100% sure why this happens. However, one reason for this could be that the squared Euclidean kernel loses power as the number of dimensions increases. If we have some dimensions that really don't influence the value of $f$ very much, keeping them around only hurts the power of our chosen kernel, so the GPR might struggle to achieve high accuracy.
Figure 4
In this example, we move to a higher dimensional function $f4 : \mathbb{R}^10 \rightarrow \mathbb{R}$. The function is just the exponential of a coefficient vector and a point $x \in \mathbb{R}^10$.
Can you write Python code for it?


I am working on the file "ASGP.ipynb".
The first task is:
and will use a randomly generated set of $N$ points on $\Delta^2$ (a two dimensional simplex)
Can you write Python code for it?

def randDelta2(N):
    x = np.random.rand(N)
    return np.column_stack([x, 1-x])

def figure1():
    np.random.seed(39)
    num_Ns = 20
    ave_errs = np.inf * np.ones(num_Ns)
    max_errs = np.inf * np.ones(num_Ns)
    Nvals = np.logspace(1, 3, num_Ns)

    # construct test points
    X_test = randDelta2(1000)
    f1_test = f1(X_test.T)

    for i, N in enumerate(Nvals):
        # training points
        X = randDelta2(int(N))
        V = f1(X.T)

        # fit GP. note that the call to `gp.fit` below does
        # maximum likelihood optimization of priors for us
        gp = GaussianProcessRegressor(RBF())
        gp.fit(X, V)

        # compute error
        m_tilde = gp.predict(X_test)
        ave_errs[i] = np.sqrt(np.sum((f1_test - m_tilde)**2 / (f1_test**2)))
        max_errs[i] = np.max(np.abs(f1_test - m_tilde))

    fig, ax = plt.subplots(figsize=(8, 5.5))
    ax.loglog(Nvals, ave_errs, ".-", ms=15, label="Average error")
    ax.loglog(Nvals, max_errs, ".-", ms=15, label="Maximum error")
    ax.legend()

    return np.column_stack([ave_errs, max_errs]), fig


I am working on the file "AStarSearch/project_notebook.ipynb".
The first task is:
Advanced Visualizations
The map above shows a network of roads which spans 40 different intersections (labeled 0 through 39).
The show_map function which generated this map also takes a few optional parameters which might be useful for visualizaing the output of the search algorithm you will write.

start - The "start" node for the search algorithm.
goal  - The "goal" node.
path  - An array of integers which corresponds to a valid sequence of intersection visits on the map.
Can you write Python code for it?

# run this code, note the effect of including the optional
# parameters in the function call.
show_map(map_40, start=5, goal=34, path=[5,16,37,12,34])


I am working on the file "AStarSearch/project_notebook.ipynb".
The first task is:
Map Basics
Can you write Python code for it?

map_10 = load_map('map-10.pickle')
show_map(map_10)


I am working on the file "AStarSearch/project_notebook.ipynb".
The first task is:
Roads
The roads property is a list where roads[i] contains a list of the intersections that intersection i connects to.
Can you write Python code for it?

# this shows that intersection 0 connects to intersections 7, 6, and 5
map_10.roads[8]

# This shows the full connectivity of the map
map_10.roads

# map_40 is a bigger map than map_10
map_40 = load_map('map-40.pickle')
show_map(map_40)

map_40.roads[24]


I am working on the file "AStarSearch/project_notebook.ipynb".
The first task is:
The map above (run the code cell if you don't see it) shows a disconnected network of 10 intersections. The two intersections on the left are connected to each other but they are not connected to the rest of the road network.
These Map objects have two properties you will want to use to implement A* search: intersections and roads
Intersections
The intersections are represented as a dictionary.
In this example, there are 10 intersections, each identified by an x,y coordinate. The coordinates are listed below. You can hover over each dot in the map above to see the intersection number.
Can you write Python code for it?


I am working on the file "AStarSearch/project_notebook.ipynb".
The first task is:
Writing your algorithm
You should open the file student_code.py in another tab and work on your algorithm there. Do that by selecting File > Open and then selecting the appropriate file.
The algorithm you write will be responsible for generating a path like the one passed into show_map above. In fact, when called with the same map, start and goal, as above you algorithm should produce the path [5, 16, 37, 12, 34]
```bash

shortest_path(map_40, 5, 34)
[5, 16, 37, 12, 34]
```
Can you write Python code for it?

path = shortest_path(map_40, 5, 34)
if path == [5, 16, 37, 12, 34]:
    print("great! Your code works for these inputs!")
else:
    print("something is off, your code produced the following:")
    print(path)


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(1b) Indentações
No Python a indentação faz o papel das chaves para determinar o bloco de comandos de uma função, condicional ou laço de repetição. O início de um bloco é definido pelo caractere ":".
Can you write Python code for it?

x = 10

for i in range(20):
    # Início da repetição For
    x = x + 1
    if x%2 == 0:
        # Instrução se condição verdadeira
        x = x + 1
    else:
        # Instrução se a condição for falsa
        x = x + 2
    # Fim do bloco de repetição For
print x # Isso está fora do for! Boa Ideia!


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(1c) Funções
As funções no Python podem receber quantas entradas necessárias e retornar múltiplas saídas. A declaração da função é precedida pela palavra-chave def.
Can you write Python code for it?

def Soma(x,y):
    return x+y

def Mult(x,y):
    return x*y

def SomaMult(x,y):
    return x+y, x*y  # múltiplas saídas separadas por vírgula

print Soma(10,2), Mult(10,2), SomaMult(10,2)

# O retorno de múltiplas saídas podem ser atribuídas diretamente para múltiplas variáveis
w,z = SomaMult(10,2)
print w, z


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(1d) Tipos Especiais
Além dos tipos básicos de variáveis o Python possui os tipos lista (list), tupla (tuple) e dicionários (dict).
As listas e tuplas são agregadores de valores e podem agrupar valores não necessariamente dos mesmos tipos. A diferença entre os dois é que listas são mutáveis (podem ser alterados) e tuplas são imutáveis. Elas são indexadas a partir do índice 0.
Os dicionários são arranjos associativos que permite associar uma chave (de qualquer tipo) a um valor (também de qualquer tipo).
Can you write Python code for it?

lista = [1, 2, True, "palavra"]
tupla = (1, 2, True, "palavra")

lista[1] = 3.0
print lista

tupla[1] = 3.0 # Vai dar erro!

# range(n) gera uma lista de valores entre 0 e n-1
# len(lista) retorna o tamanho de uma lista
def DobraValores(lista):
    for i in range(len(lista)):
        lista[i] = lista[i]*2
    return lista

lista = [1,2,3,4]
lista2 = DobraValores(lista)

print lista, lista2  # As listas são passadas como referência para as funções

dicionario = { "Ana":12, "Joao":13, "Jose":17 }  # declaração inicial do dicionário, pode ser {} para dic. vazio
print dicionario["Ana"]  # acesso ao elemento pela chave entre colchetes

dicionario["Maria"] = 11  # podemos alterar ou inserir um novo elemento

print dicionario

print "As chaves do dicionário são: ", dicionario.keys()
print "Os valores do dicionário são: ", dicionario.values()


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(1e) Iteradores
Para iterar por uma lista, tupla ou dicionário podemos utilizar a palavra-chave in. Em conjunto com a instrução for ela percorre cada elemento iterativamente. Essa palavra-chave também pode ser utilizada para verificar se um elemento está contido na lista.
Can you write Python code for it?

lista = range(10)  # gera a lista [0,..,9]
print 8 in lista, 12 in lista

for x in lista:
    print x


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(1g) Arquivos
A leitura de arquivos é feita pelo comando open() que gera um apontador para arquivo, podemos utilizar o laço for para ler cada linha do arquivo iterativamente como uma string.
Can you write Python code for it?

import os.path

caminho = os.path.join('Data','Aula01')  # garante o uso correto de / ou \\ para diretórios
arquivo = os.path.join(caminho,'exemplo.txt')

f = open(arquivo)
for linha in f:
    print linha
f.close()


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(2b) Multiplicação elemento-a-elemento e produto interno
A multiplicação elemento-a-elemento é calculada como: $$ \mathbf{x} \odot \mathbf{y} =  \begin{bmatrix} x_1 y_1 \\  x_2 y_2 \\ \vdots \\ x_n y_n \end{bmatrix} $$
E o do produto interno de dois vetores de mesmo tamanho $ n $: $$ \mathbf{w} \cdot \mathbf{x} = \sum_{i=1}^n w_i x_i $$
Em alguns livros você também vê $ \mathbf{w} \cdot \mathbf{x} $ escrito como  $ \mathbf{w}^\top \mathbf{x} $
O tipo Numpy Array suporta essas duas operações, ao utilizar o operador * para multiplicar dois vetores ou matrizes, ele executará a multiplicação elemento-a-elemento. Para realizar o produto interno você pode utilizar tanto a função np.dot() ou ndarray.dot(). Ex.: dados os vetores $x$ e $y$ pode realizar a operação como np.dot(x,y) ou x.dot(y).
Can you write Python code for it?

# EXERCICIO
# A função np.arange(inicio,fim,passo)  cria uma lista iniciando em inicio, terminando antes do fim seguindo passo
u = np.arange(0, 5, .5)   # np.array([0,0.5,1.0,...,4.5])
v = np.arange(5, 10, .5)

elementoAelemento = u*v#<COMPLETAR>
prodInterno = u.dot(v)#<COMPLETAR>
print 'u: {0}'.format(u)
print 'v: {0}'.format(v)
print '\nelementoAelemento\n{0}'.format(elementoAelemento)
print '\nprodInterno\n{0}'.format(prodInterno)

# TESTE do exercício (2b)
assert np.all(elementoAelemento == [ 0., 2.75, 6., 9.75, 14., 18.75, 24., 29.75, 36., 42.75]), "Valores incorretos para elementoAelemento"
print "Primeiro teste OK"
assert prodInterno==183.75, "Valor incorreto para prodInterno"
print "Segundo teste OK"


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(2c) Multiplicação de Matriz
A multiplicação de matriz é definida por:
$$ [\mathbf{X} \mathbf{Y}]{i,j} = \sum{r=1}^n \mathbf{X}{i,r} \mathbf{Y}{r,j} $$
Note que o número de colunas da primeira matriz deve ser o mesmo do número de linhas da segunda matriz, representada por  $ n $
No Numpy utilizamo np.matrix() quando queremos criar uma matriz a partir de listas do Python. Com esse tipo podemos utilizar o operador * para multiplicação de matrizes, np.multiply() para multiplicação elemento-a-elemento, np.matrix.transpose() ou .T para calcular a transposta e np.linalg.inv() para calcular a inversa de uma matriz quadrada.
Can you write Python code for it?

# EXERCICIO
from numpy.linalg import inv  # agora podemos utilizar o comando inv() sem preceder com np.linalg

# Criar uma matriz com listas de listas
A = np.matrix([[1,2,3,4],[5,6,7,8]])
print 'A:\n{0}'.format(A)

# Imprima a matriz transposta
print '\nA transposta:\n{0}'.format(A.T)#<COMPLETAR>)

# Multiplique A por sua Transposta
AAt = A*A.T #<COMPLETAR>
print '\nAAt:\n{0}'.format(AAt)

# Inverta AAt com o comando inv()
AAtInv = inv(AAt)#<COMPLETAR>
print '\nAAtInv:\n{0}'.format(AAtInv)

# Mostre que a matriz vezes sua inversa é a identidade
# .round(n) arredonda os valores para n casas decimais
print '\nAAtInv * AAt:\n{0}'.format((AAt*AAtInv).round(4))#<COMPLETAR>).round(4))

# TESTE do exercício (2c)
assert np.all(AAt == np.matrix([[30, 70], [70, 174]])), "Valores incorretos para AAt"
print "Primeiro teste OK"
assert np.allclose(AAtInv, np.matrix([[0.54375, -0.21875], [-0.21875, 0.09375]])), "Valor incorreto para AAtInv"
print "Segundo teste OK"


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(2d) Slices
Nos vetores e matrizes do Numpy podemos selecionar sub-conjuntos de valores durante a indexação. Ex.:
v[:10] seleciona os 10 primeiros elementos
v[2:]  seleciona os elementos da terceira posição em diante
v[-5:] retorna os 5 últimos elementos
v[:-5] retorna os elementos do começo até o ultimo-5
v[1:3] retorna os elementos 1 e 2
Can you write Python code for it?

# EXERCICIO
atributos = np.array([1, 2, 3, 4])
print 'atributos:\n{0}'.format(atributos)

# Crie uma array com os 3 últimos elementos de atributos
ultTres = atributos[-3:]#[<COMPLETAR>]

print '\nÚltimos três:\n{0}'.format(ultTres)

# TEST do exercício (2d)
assert np.all(ultTres == [2, 3, 4]), "Valores incorretos para ultTres"
print "Teste OK"


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(3b) Lógica Funcional
No paradigma funcional trabalhamos com os conceitos de dados imutáveis, ou seja, não existe o conceito de variáveis, uma vez que um valor é designado a um nome, esse valor não pode mudar.
Can you write Python code for it?

# Lógica não-funcional
a = 0
def inc():
    global a
    a = a + 1

# Lógica funcional
def incFn(a):
    return a+1


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(3c) Funções de Alta Ordem
Desse modo, o uso de laços (for, while) é desencorajado e substituídos pela recursividade e funções de alta ordem. Uma função de alta ordem é uma função que recebe uma ou mais funções como parâmetro e retorna uma função.
Can you write Python code for it?

# Função para somar 3 valores
def Soma3(a,b,c):
    return a+b+c

# Função que soma apenas dois valores
def Soma2(a,b):
    return a+b

# Soma 3 poderia ser criado a partir de Soma2:
Soma3Fn = lambda a,b,c: Soma2(Soma2(a,b),c)


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
(3d) Map, Reduce, Filter
Essas três funções são utilizadas para transformação de listas no paradigma funcional. Essas funções recebem como parâmetro uma função f e uma lista l.
Map: aplica a função em cada elemento da lista, gerando uma nova lista
Reduce: aplica a função cumulativamente em pares de elementos da lista, retornando um único valor agregado ao final
Filter: gera uma nova lista contendo os elementos da lista l em que a aplicação de f returna True
Para os próximos exercícios vamos utilizar a classe FuncionalW para criar uma sintaxe parecida com a que utilizaremos com o Spark.
Can you write Python code for it?

class FuncionalW(object):
    def __init__(self, data):
        self.data = data
    def map(self, function):
        """Call `map` on the items in `data` using the provided `function`"""
        return FuncionalW(map(function, self.data))
    def reduce(self, function):
        """Call `reduce` on the items in `data` using the provided `function`"""
        return reduce(function, self.data)
    def filter(self, function):
        """Call `filter` on the items in `data` using the provided `function`"""
        return FuncionalW(filter(function, self.data))
    def __eq__(self, other):
        return (isinstance(other, self.__class__)
            and self.__dict__ == other.__dict__)
    def __getattr__(self, name):  return getattr(self.data, name)
    def __getitem__(self, k):  return self.data.__getitem__(k)
    def __repr__(self):  return 'FuncionalW({0})'.format(repr(self.data))
    def __str__(self):  return 'FuncionalW({0})'.format(str(self.data))

# Exemplo de Map

# Criaremos uma lista
lista = FuncionalW(range(10))

# Criar uma função a ser aplicada nessa lista
f = lambda x: x*x

# Programação Imperativa
resultado1 = FuncionalW([])
for x in lista:
    resultado1.append(f(x))
print "Resultado: {}".format(resultado1)

# Funcional
print "Resultado usando Map: {}".format(lista.map(f))

# Exemplo de Reduce

# Criaremos uma lista
lista = FuncionalW(range(1,10))

# Criar uma função a ser aplicada nessa lista
f = lambda x,y: x*y

# Programação Imperativa
produtoria = 1
for x in lista:
    produtoria = f(produtoria,x)
print "Resultado: {}".format(produtoria)

# Funcional
print "Resultado usando Reduce: {}".format(lista.reduce(f))

# EXERCICIO

dataset = FuncionalW(range(10))

# Multiplique cada elemento por 5
mapResult = dataset.map(lambda x:x*5)#<COMPLETAR>
# Filtre eliminando os elementos ímpares
# No Python "x % 2" é o resultado do resto da divisão de x por 2
filterResult = dataset.filter(lambda x: x%2==0)#<COMPLETAR>
# Some os elementos
reduceResult = dataset.reduce(lambda x,y:...


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
As funções lambdas tem restrições em relação a expressão computada. Essa expressão não pode conter print ou incremento +=, por exemplo.
Além disso, os parâmetros de entrada podem ser de qualquer tipo, incluindo tuplas e listas.
Can you write Python code for it?

p1 = (1,3)
p2 = (3,7)

euclidiana2D = lambda (x0,y0), (x1,y1): np.sqrt(((x0-x1)**2) + ((y0-y1)**2))  # sqrt é a raíz quadrada
print euclidiana2D(p1,p2)


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
Para reduzir o tamanho do código e facilitar a leitura, podemos compor as funções em sequência
Can you write Python code for it?

dataset = FuncionalW(range(10))

Soma = (dataset
            .map(lambda x: x*5)
            .filter(lambda x: x%2==0)
            .reduce(lambda x,y: x+y)
            )
print Soma

# EXERCICIO

# split() divide a string em palavras
Texto = FuncionalW("Esse texto tem varias palavras cada linha tem palavras escritas palavras palavras palavras Esse texto esta escrito".split())

# Vamos fazer uma contagem da palavra 'palavras' no texto

# Crie uma função lambda que recebe duas entradas e retorna se são iguais ou não
Igual = lambda x,y:x==y #<COMPLETAR>

# Crie uma função lambda que utiliza a função Igual para detectar se a entrada é igual a palavra 'palavras'
DetectaPalavra = lambda x: Igual(x,"palavras")#<COMPLETAR>

# 1) Filtre as palavras iguais a 'palavras'
# 2) Mapeie todos os elementos para o valor 1
# 3) Reduza para a somatória
contagem = (Texto
            .filter(DetectaPalavra)#<COMPLETAR>
            .map(lambda x:1)#<COMPLETAR>
            .reduce(lambda x,y: x+y) #<COMPLETAR>
            )
print(contagem)
#print "Existem {0} ocorrências de 'palavras'".format(contagem)


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
Parte 3: Programação Funcional
 (3a) Funções Anônimas (Lambda)
Uma função/expressão lambda é utilizada para definir funções simples com apenas uma instrução. Para isso basta usar a instrução lambda seguido da lista de parâmetros de entrada, precedidos por : e a expressão a ser executada. Por exempo, lambda x, y: x + y é uma função anônima que calcula a soma de dois valores.
Expressões lambda geram uma função quando interpretadas pelo Python. Elas são úteis quando precisamos aplicar uma função simples em diversos elementos de uma lista.
Para saber mais sobre Lambdas: Lambda Functions, Lambda Tutorial, and Python Functions.
No exercício abaixo crie uma função lambda que multiplique um valor por 10, atribua a variável designada.
Can you write Python code for it?

# EXERCICIO
# Lembre-se que: "lambda x, y: x + y" cria uma função que adiciona dois valores
mult10 = lambda x: x*10#<COMPLETAR>
print mult10(5)

# Note that the function still shows its name as <lambda>
print '\n', mult10

assert mult10(10)==100, "Função incorreta"
print "Teste OK"


I am working on the file "ATIVIDADE2/Lab1_Rev_Python_Numpy_AlgeLin.ipynb".
The first task is:
Quando precisamos trabalhar com listas muito grandes, mas sem a necessidade de acessar os elementos aleatóriamente, podemos utilizar os geradores.
Um gerador define a instrução para gerar uma sequência, calculando cada elemento da sequência conforme requisitado.
Can you write Python code for it?

listaQuadrada = ( x*x for x in listaOriginal )
print listaQuadrada # os elementos ainda não foram calculados

for x in listaQuadrada:
    print x # a cada iteração apenas o próximo elemento é calculado, a lista não existe na memória


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(1b) Plural
Vamos criar uma função que transforma uma palavra no plural adicionando uma letra 's' ao final da string. Em seguida vamos utilizar a função map() para aplicar a transformação em cada palavra do RDD.
Em Python (e muitas outras linguagens) a concatenação de strings é custosa. Uma alternativa melhor é criar uma nova string utilizando str.format().
Nota: a string entre os conjuntos de três aspas representa a documentação da função. Essa documentação é exibida com o comando help(). Vamos utilizar a padronização de documentação sugerida para o Python, manteremos essa documentação em inglês.
Can you write Python code for it?

# EXERCICIO
def Plural(palavra):
    """Adds an 's' to `palavra`.

    Args:
        palavra (str): A string.

    Returns:
        str: A string with 's' added to it.
    """
    return "{0}{1}".format(palavra,"s")#<COMPLETAR>

print Plural('gato')

help(Plural)

assert Plural('rato')=='ratos', 'resultado incorreto!'
print 'OK'


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(1c) Aplicando a função ao RDD
Transforme cada palavra do nosso RDD em plural usando map()
Em seguida, utilizaremos o comando  collect() que retorna a RDD como uma lista do Python.
Can you write Python code for it?

# EXERCICIO
pluralRDD = palavrasRDD.map(Plural)#<COMPLETAR>
print pluralRDD.collect()

assert pluralRDD.collect()==['gatos','elefantes','ratos','ratos','gatos'], 'valores incorretos!'
print 'OK'


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(2c) reduceByKey
Um comando mais interessante para a contagem é o  reduceByKey() que cria uma nova RDD de tuplas.
Essa transformação aplica a transformação reduce() vista na aula anterior para os valores de cada chave. Dessa forma, a função de transformação pode ser aplicada em cada partição local para depois ser enviada para redistribuição de partições, reduzindo o total de dados sendo movidos e não mantendo listas grandes na memória.
Can you write Python code for it?

# EXERCICIO
from operator import add
contagem = palavraPar.reduceByKey(add)#<COMPLETAR>
print contagem.collect()

assert sorted(contagem.collect())==[('elefante',1), ('gato',2), ('rato',2)], 'valores incorretos!'
print "OK"


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(2d) Agrupando os comandos
A forma mais usual de realizar essa tarefa, partindo do nosso RDD palavrasRDD, é encadear os comandos map e reduceByKey em uma linha de comando.
Can you write Python code for it?

# EXERCICIO
contagemFinal = (palavrasRDD.map(lambda x:(x,1)).reduceByKey(add)
                 #<COMPLETAR>
                 #<COMPLETAR>
                 )
contagemFinal = contagemFinal.collect()
print contagemFinal

assert sorted(contagemFinal)==[('elefante',1), ('gato',2), ('rato',2)], 'valores incorretos!'
print "OK"


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(3b) Calculando a Média de contagem de palavras
Encontre a média de frequência das palavras utilizando o RDD contagem.
Note que a função do comando reduce() é aplicada em cada tupla do RDD. Para realizar a soma das contagens, primeiro é necessário mapear o RDD para um RDD contendo apenas os valores das frequências (sem as chaves).
Can you write Python code for it?

# EXERCICIO
# add é equivalente a lambda x,y: x+y
palavrasRDD2 = sc.parallelize(contagemFinal)
#print palavrasRDD2.collect()
total = (palavrasRDD2.map(lambda x:(x[1])).reduce(add))
media = total / float(palavrasUnicas)
print total
print round(media, 2)

assert round(media, 2)==1.67, 'valores incorretos!'
print "OK"


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(4c) Carregando arquivo texto
Para a próxima parte vamos utilizar o livro Trabalhos completos de William Shakespeare do Projeto Gutenberg.
Para converter um texto em uma RDD, utilizamos a função textFile() que recebe como entrada o nome do arquivo texto que queremos utilizar e o número de partições.
O nome do arquivo texto pode se referir a um arquivo local ou uma URI de arquivo distribuído (ex.: hdfs://).
Vamos também aplicar a função removerPontuacao() para normalizar o texto e verificar as 15 primeiras linhas com o comando take().
Can you write Python code for it?

# Apenas execute a célula
import os.path
import urllib2

url = 'http://www.gutenberg.org/cache/epub/100/pg100.txt' # url do livro

arquivo = os.path.join('Data','Aula02','shakespeare.txt') # local de destino: 'Data/Aula02/shakespeare.txt'

if os.path.isfile(arquivo):     # verifica se já fizemos download do arquivo
    print 'Arquivo já existe!'
else:
    try:
        response = urllib2.urlopen(url)
        arquivo = (response.read()).split() #ja gera uma lista de palavras
    except IOError:
        print 'Impossível fazer o download: {0}'.format(url)

# lê o arquivo com textFile e aplica a função removerPontuacao
shakesRDD = (sc.textFile(arquivo).map(removerPontuacao))

# zipWithIndex gera tuplas (conteudo, indice) onde indice é a posição do conteudo na lista sequencial
# Ex.: sc.parallelize(['gato','cachorro','boi']).zipWithIndex() ==> [('gato',0), ('cachorro',1), ('boi',2)]
# sep.join() junta as strings de uma lista através do separador sep. Ex.: ','.join(['a','b','c']) ==> 'a,b,c'
print '\n'.join(shakesRDD
                .zipWithIndex()
                .map(lambda (linha, num): '{0}: {1}'.format(num,linha))
                .take(15)
               )


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(4e) Remover linhas vazias
Para o próximo passo vamos filtrar as linhas vazias com o comando filter(). Uma linha vazia é uma string sem nenhum conteúdo.
Can you write Python code for it?

# EXERCICIO
shakesLimpoRDD = shakesPalavrasRDD.filter(lambda x: len(x)>0)#<COMPLETAR>
total = shakesLimpoRDD.count()
print total

assert total==882996, 'valor incorreto!'
print "OK"


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
(5b) Valores Categóricos
Quando nossos objetos são representados por atributos categóricos, eles não possuem uma similaridade espacial. Para calcularmos a similaridade entre eles podemos primeiro transformar nosso vetor de atrbutos em um vetor binário indicando, para cada possível valor de cada atributo, se ele possui esse atributo ou não.
Com o vetor binário podemos utilizar a distância de Hamming  definida por:
$$ H(x,y) = \sum_{i=1}^{n}{x_i != y_i} $$
Também é possível definir a distância de Jaccard como:
$$ J(x,y) = \frac{\sum_{i=1}^{n}{x_i == y_i} }{\sum_{i=1}^{n}{\max(x_i, y_i}) } $$
Can you write Python code for it?

# Vamos criar uma função para calcular a distância de Hamming
def Hamming(x,y):
    """Calculates the Hamming distance between two binary vectors.

    Args:
        x, y (np.array): Array of binary integers x and y.

    Returns:
        H (int): The Hamming distance between x and y.
    """
    return (x!=y).sum()

# Vamos criar uma função para calcular a distância de Jaccard
def Jaccard(x,y):
    """Calculates the Jaccard distance between two binary vectors.

    Args:
        x, y (np.array): Array of binary integers x and y.

    Returns:
        J (int): The Jaccard distance between x and y.
    """
    return (x==y).sum()/float( np.maximum(x,y).sum() )

# Vamos criar uma RDD com valores categóricos
catPointsRDD = sc.parallelize(enumerate([['alto', 'caro', 'azul'],
                             ['medio', 'caro', 'verde'],
                             ['alto', 'barato', 'azul'],
                             ['medio', 'caro', 'vermelho'],
                             ['baixo', 'barato', 'verde'],
                            ]))

# EXERCICIO

# Crie um RDD de chaves únicas utilizando flatMap
chavesRDD = catPointsRDD.flatMap(lambda x: (x[1])).distinct()#.zipWithIndex()

chaves = dict((v,k) for k,v in enumerate(chavesRDD.collect()))
nchaves = len(chaves)
print chaves, nchaves

assert chaves=={'alto': 0, 'medio': 1, 'baixo': 2, 'barato': 3, 'azul': 4, 'verde': 5, 'caro': 6, 'vermelho': 7}, 'valores incorretos!'
print "OK"

assert nchaves==8, 'número de chaves incorreta'
print "OK"

def CreateNP(atributos,chaves):
    """Binarize the categorical vector using a dictionary of keys.

    Args:
        atributos (list): List of attributes of a given object.
        chaves (dict): dictionary with the relation attribute -> index

    Returns:
        array (np.array): Binary array of attributes.
    """

    array = np.zeros(len(chaves))
    for atr in atributos:
        array[ chaves[atr] ] = 1
    return array

# Converte o RDD para o formato binário, utilizando o dict chaves
binRDD = catPointsRDD.map(lambda...


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
Conforme deve ter percebido, o uso da função map() gera uma lista para cada linha, criando um RDD contendo uma lista de listas.
Para resolver esse problema, o Spark possui uma função análoga chamada flatMap() que aplica a transformação do map(), porém achatando o retorno em forma de lista para uma lista unidimensional.
Can you write Python code for it?

# EXERCICIO
shakesPalavrasRDD = shakesRDD.flatMap(lambda x: x.split())
total = shakesPalavrasRDD.count()
print shakesPalavrasRDD.top(5)
print total


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
Nota:  utilize o comando collect() apenas quando tiver certeza de que a lista caberá na memória. Para gravar os resultados de volta em arquivo texto ou base de dados utilizaremos outro comando.
 (1d) Utilizando uma função lambda
Repita a criação de um RDD de plurais, porém utilizando uma função lambda.
Can you write Python code for it?

# EXERCICIO
pluralLambdaRDD = palavrasRDD.map(lambda x: "{0}{1}".format(x,"s"))#<COMPLETAR>
print pluralLambdaRDD.collect()

assert pluralLambdaRDD.collect()==['gatos','elefantes','ratos','ratos','gatos'], 'valores incorretos!'
print 'OK'


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
Nota: os asserts abaixo de contagem de palavra podem falhar por diferença de formato do arquivo .txt antigo e novo. Eu avaliarei somente os códigos nesse trecho.
Can you write Python code for it?

#assert total==927631 or total == 928908, "valor incorreto de palavras!"
#print "OK"
assert shakesPalavrasRDD.top(5)==[u'zwaggerd', u'zounds', u'zounds', u'zounds', u'zounds'],'lista incorreta de palavras'
print "OK"


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
Parte 2: Manipulando RDD de tuplas
Vamos manipular nossa RDD para contar as palavras do texto.
 (2a) Função groupByKey()
A função groupByKey() agrupa todos os valores de um RDD através da chave (primeiro elemento da tupla) agregando os valores em uma lista.
Essa abordagem tem um ponto fraco pois:

A operação requer que os dados distribuídos sejam movidos em massa para que permaneçam na partição correta.

As listas podem se tornar muito grandes. Imagine contar todas as palavras do Wikipedia: termos comuns como "a", "e" formarão uma lista enorme de valores que pode não caber na memória do processo escravo.
Can you write Python code for it?

# EXERCICIO
palavrasGrupo = palavraPar.groupByKey()
for chave, valor in palavrasGrupo.collect():
    print '{0}: {1}'.format(chave, list(valor))

assert sorted(palavrasGrupo.mapValues(lambda x: list(x)).collect()) == [('elefante', [1]), ('gato',[1, 1]), ('rato',[1, 1])],        'Valores incorretos!'
print "OK"


I am working on the file "ATIVIDADE2/Lab2_Spark_PySpark.ipynb".
The first task is:
Parte 4: Aplicar nosso algoritmo em um arquivo
 (4a) Função contaPalavras
Para podermos aplicar nosso algoritmo genéricamente em diversos RDDs, vamos primeiro criar uma função para aplicá-lo em qualquer fonte de dados. Essa função recebe de entrada um RDD contendo uma lista de chaves (palavras) e retorna um RDD de tuplas com as chaves e a contagem delas nessa RDD
Can you write Python code for it?

# EXERCICIO
def contaPalavras(chavesRDD):
    """Creates a pair RDD with word counts from an RDD of words.

    Args:
        chavesRDD (RDD of str): An RDD consisting of words.

    Returns:
        RDD of (str, int): An RDD consisting of (word, count) tuples.
    """
    return (chavesRDD.map(lambda x: (x,1)).reduceByKey(add)
            #<COMPLETAR>
            #<COMPLETAR>
           )

print contaPalavras(palavrasRDD).collect()

assert sorted(contaPalavras(palavrasRDD).collect())==[('elefante',1), ('gato',2), ('rato',2)], 'valores incorretos!'
print "OK"


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
(3c) Gráfico de Dispersão
O gráfico de dispersão é utilizado para visualizar correlações entre as variáveis. Com esse gráfico é possível observar se o crescimento da quantidade de uma categoria está relacionada ao crescimento/decrescimento de outra (mas não podemos dizer se uma causa a outra).
Na primeira parte do exercício calcularemos a correlação entre os diferentes tipos de crime. Para isso primeiro precisamos construir uma RDD em que cada registro corresponde a uma data o valor contido nele é a quantidade de crimes de cada tipo.
Diferente dos exercícios anteriores, devemos manter essa informação como uma lista de valores em que todos os registros sigam a mesma ordem da lista de crimes.
O primeiro passo é criar uma RDD com a tupla ( (Mes-Ano, Crime), 1 ) e utilizá-la para gerar a tupla ( (Mes-Ano,Crime) Quantidade ).
Mapeamos essa RDD para definir Mes-Ano como chave e agrupamos em torno dessa chave, gerando uma lista de quantidade de crimes em cada data. Aplicamos a função dict() nessa lista para obtermos uma RDD no seguinte formato: (Mes-Ano, {CRIME: quantidade}).
Além disso, vamos criar a variável crimes contendo a lista de crimes contidas na lista de pares catCount computada anteriormente.
Can you write Python code for it?

# EXERCICIO
parseMonthYear = lambda x: '{}-{}'.format(x.month, x.year)

crimes = map(lambda x: x[0], catCount)

datesCrimesRDD = (CrimeHeadlessRDD
                  .map(lambda x: ((parseMonthYear(x.Dates),x.Category),1))#<COMPLETAR>
                  .reduceByKey(add)#<COMPLETAR>
                  .map(lambda ((ma,crime),contagem):(ma,(crime,contagem)))#<COMPLETAR>
                  .groupByKey()#<COMPLETAR>
                  .map(lambda y:(y[0],dict(y[1])))#<COMPLETAR>
                 )

#print datesCrimesRDD.collect()
print datesCrimesRDD.take(1)

assert datesCrimesRDD.take(1)[0][1][u'KIDNAPPING']==12,'valores incorretos'
print 'ok'


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
(3d) Histograma
O uso do Histograma é para visualizar a distribuição dos dados. Dois tipos de distribuição que são observadas normalmente é a Gaussiana, em que os valores se concentram em torno de uma média e a Lei de Potência, em que os valores menores são observados com maior frequência.
Vamos verificar a distribuição das prisões efetuadas (categoria ARREST em * Resolution*) em cada mês. Com essa distribuição poderemos verificar se o número de prisões é consistente durante os meses do período estudado.
Primeiro criaremos uma RDD chamada bookedRDD que contém apenas os registros contendo ARREST no campo Resolution (lembre-se que esse campo é uma lista) e contabilizar a quantidade de registros em cada 'Mes-Ano'. Ao final, vamos mapear para uma RDD contendo apenas os valores contabilizados.
Can you write Python code for it?

# EXERCICIO

bookedRDD = (CrimeHeadlessRDD
             .filter(lambda x: u'"ARREST' in x.Resolution)#<COMPLETAR>
             .map(lambda y:(parseMonthYear(y.Dates),1))#<COMPLETAR>
             .reduceByKey(add)#<COMPLETAR>
             .map(lambda z:z[1])#.<COMPLETAR>
            )

Data = bookedRDD.collect()
#print Data
print Data[:5]

assert Data[0]==1914,'valores incorretos'
print 'ok'

fig = plt.figure(figsize=(8,4.2), facecolor='white', edgecolor='white')
plt.hist(Data)
plt.grid(b=True, which='major', axis='y')
plt.xlabel('ARRESTED')
pass


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
Agora temos um dataset em que cada linha é uma string contendo todos os valores. Porém, para explorarmos os dados precisamos que cada objeto seja uma lista de valores.
Utilize o comando split() para transformar os objetos em listas de strings.
Can you write Python code for it?

# EXERCICIO
CrimeHeadlessRDD = (CrimeRDD.filter(lambda x: x!=header).map(lambda y: y.split(",")))
                    #.map(lambda x: x!= header)#<COMPLETAR>
                    #.map(lambda y: y.split()#<COMPLETAR>
                    #)

firstObjectList = CrimeHeadlessRDD.take(1)[0]
print firstObjectList

assert firstObjectList[0]==u'2015-05-13 23:53:00', 'valores incorretos'
print "OK"


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
Convertendo a matriz corr para np.array podemos buscar pelo maior valor negativo e positivo diferentes de 1.0. Para isso vamos utilizar as funções min() e argmin().
Can you write Python code for it?

npCorr = np.array(corr)
rowMin = npCorr.min(axis=1).argmin()
colMin = npCorr[rowMin,:].argmin()
print crimes[rowMin], crimes[colMin], npCorr[rowMin,colMin]

npCorr[npCorr==1.] = 0.
rowMax = npCorr.max(axis=1).argmax()
colMax = npCorr[rowMax,:].argmax()
print crimes[rowMax], crimes[colMax], npCorr[rowMax,colMax]


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
De forma similar, vamos gerar a contagem para as regiões de São Francisco (PdDistrict).
Can you write Python code for it?

# EXERCICIO

RegionCountRDD = CrimeHeadlessRDD.map(lambda x:(x.PdDistrict,1)).reduceByKey(add)
                 # .<COMPLETAR>
                 # .<COMPLETAR>
                 #)
regCount = sorted(RegionCountRDD.collect(), key=lambda x: -x[1])
print regCount

assert regCount[0][1]==157182, 'valores incorretos'
print "OK"


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
Finalmente, utilizaremos a função Statistics.corr() da biblioteca pyspark.mlllib.stat.
Para isso mapeamos nossa RDD para conter apenas a lista de valores da lista de tuplas.
Can you write Python code for it?

from pyspark.mllib.stat import Statistics
corr = Statistics.corr(fractionCrimesDateRDD.map(lambda rec: map(lambda x: x[1],rec[1])))
print corr


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
No gráfico abaixo, percebemos que existem, em média, muito mais prisões para o tipo ASSAULT do que o tipo ROBBERY, ambos com pequena variação.
Can you write Python code for it?

fig = plt.figure(figsize=(8,4.2), facecolor='white', edgecolor='white')
plt.boxplot([robData,assData])
plt.grid(b=True, which='major', axis='y')
plt.ylabel('ARRESTED')
plt.xticks([1,2], ['ROBBERY','ASSAULT'])
pass


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
Notem que lemos o histograma da seguinte maneira: em cerca de 50 meses foram observadas entre 1750 e 2000 prisões. Porém, não sabemos precisar em quais meses houve um aumento ou redução das prisões. Isso deve ser observado através de um gráfico de linha.
(3e) Box-plot
O Box-plot é um gráfico muito utilizado em estatística para visualizar o resumo estatístico de uma variável.
Para esse exercício vamos plotar duas box-plot sobre a média do número de prisões durante os meses analisados para os crimes do tipo ROBBERY e ASSAULT.
O mapeamento é exatamente o mesmo do exercício anterior, porém filtrando para o tipo de roubo analisado.
Can you write Python code for it?

# EXERCICIO

parseDayMonth = lambda x: '{}-{}'.format(x.month,x.year)

bookedRDD = (CrimeHeadlessRDD
             .filter(lambda x: u'"ARREST' in x.Resolution)#<COMPLETAR>
             .map(lambda y:(parseMonthYear(y.Dates),1))#<COMPLETAR>
             .reduceByKey(add)#<COMPLETAR>
             .map(lambda z:z[1])#.<COMPLETAR>
            )

robberyBookedRDD = (CrimeHeadlessRDD
                    .filter(lambda x: u'"ARREST' in x.Resolution and x.Category == "ROBBERY")#<COMPLETAR>
                    .map(lambda y:(parseMonthYear(y.Dates),1))#<COMPLETAR>
                    .reduceByKey(add)#<COMPLETAR>
                    .map(lambda z:z[1])#.<COMPLETAR>
                   )

assaultBookedRDD = (CrimeHeadlessRDD
                    .filter(lambda x: u'"ARREST' in x.Resolution and x.Category == "ASSAULT")#<COMPLETAR>
                    .map(lambda y:(parseMonthYear(y.Dates),1))#<COMPLETAR>
                    .reduceByKey(add)#<COMPLETAR>
                    .map(lambda z:z[1])#.<COMPLETAR>
                   )

robData = robberyBookedRDD.collect()
assData = assaultBookedRDD.collect()

assert robData[0]==27,'valores incorretos'
print 'ok'
assert assData[0]==152,'valores incorretos'
print 'ok'


I am working on the file "ATIVIDADE2/Lab3_AnaliseExploratoria.ipynb".
The first task is:
Parte 2: Estatísticas Básicas das Variáveis
Nessa parte do notebook vamos aprender a filtrar a base de dados para calcular estatísticas básicas necessárias para a análise exploratória.
 (2a) Contagem de frequência
A contagem de frequência é realizada de forma similar ao exercício de contagem de palavras. Primeiro mapeamos a variável de interesse. Como exemplo vamos gerar uma lista da quantidade total de cada tipo de crime (Category).
Can you write Python code for it?

# EXERCICIO
from operator import add
CatCountRDD = CrimeHeadlessRDD.map(lambda x:(x.Category,1)).reduceByKey(add)
               #.<COMPLETAR>
               #.<COMPLETAR>
               #)
#contagemFinal = (palavrasRDD.map(lambda x:(x,1)).reduceByKey(add)
catCount = sorted(CatCountRDD.collect(), key=lambda x: -x[1])
print catCount

assert catCount[0][1]==174900, 'valores incorretos'
print "OK"


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(1b) Usando LabeledPoint
Na MLlib, bases de dados rotuladas devem ser armazenadas usando o objeto LabeledPoint.  Escreva a função parsePoint que recebe como entrada uma amostra de dados, transforma os dados usandoo comando unicode.split, e retorna um LabeledPoint.
Aplique essa função na variável samplePoints da célula anterior e imprima os atributos e rótulo utilizando os atributos LabeledPoint.features e LabeledPoint.label. Finalmente, calcule o número de atributos nessa base de dados.
Can you write Python code for it?

from pyspark.mllib.regression import LabeledPoint
import numpy as np

# Here is a sample raw data point:
# '2001.0,0.884,0.610,0.600,0.474,0.247,0.357,0.344,0.33,0.600,0.425,0.60,0.419'
# In this raw data point, 2001.0 is the label, and the remaining values are features

# EXERCICIO
def parsePoint(line):
    """Converts a comma separated unicode string into a `LabeledPoint`.

    Args:
        line (unicode): Comma separated unicode string where the first element is the label and the
            remaining elements are features.

    Returns:
        LabeledPoint: The line is converted into a `LabeledPoint`, which consists of a label and
            features.
    """
    Point = line.split(",")#<COMPLETAR>
    return LabeledPoint(Point[0],Point[1:])#<COMPLETAR>)

parsedSamplePoints = map(parsePoint,samplePoints)
firstPointFeatures = parsedSamplePoints[0].features
firstPointLabel = parsedSamplePoints[0].label
print firstPointFeatures, firstPointLabel

d = len(firstPointFeatures)
print d

# TEST Using LabeledPoint (1b)
Test.assertTrue(isinstance(firstPointLabel, float), 'label must be a float')
expectedX0 = [0.8841,0.6105,0.6005,0.4747,0.2472,0.3573,0.3441,0.3396,0.6009,0.4257,0.6049,0.4192]
Test.assertTrue(np.allclose(expectedX0, firstPointFeatures, 1e-4, 1e-4),
                'incorrect features for firstPointFeatures')
Test.assertTrue(np.allclose(2001.0, firstPointLabel), 'incorrect label for firstPointLabel')
Test.assertTrue(d == 12, 'incorrect number of features')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(1c) Deslocando os rótulos
Para melhor visualizar as soluções obtidas, calcular o erro de predição e visualizar a relação dos atributos com os rótulos, costuma-se deslocar os rótulos para iniciarem em zero.
Dessa forma vamos verificar qual é a faixa de valores dos rótulos e, em seguida, subtrair os rótulos pelo menor valor encontrado. Em alguns casos também pode ser interessante normalizar tais valores dividindo pelo valor máximo dos rótulos.
Can you write Python code for it?

# EXERCICIO
parsedDataInit = rawData.map(parsePoint)
onlyLabels = parsedDataInit.map(lambda x:x.label)#<COMPLETAR>
minYear = onlyLabels.min()#<COMPLETAR>
maxYear = onlyLabels.max()#<COMPLETAR>
print maxYear, minYear

# TEST Find the range (1c)
Test.assertEquals(len(parsedDataInit.take(1)[0].features), 12,
                  'unexpected number of features in sample point')
sumFeatTwo = parsedDataInit.map(lambda lp: lp.features[2]).sum()
Test.assertTrue(np.allclose(sumFeatTwo, 3158.96224351), 'parsedDataInit has unexpected values')
yearRange = maxYear - minYear
Test.assertTrue(yearRange == 89, 'incorrect range for minYear to maxYear')

# EXERCICIO
parsedData = parsedDataInit.map(lambda x: LabeledPoint(x.label-minYear,x.features))#<COMPLETAR>

# Should be a LabeledPoint
print type(parsedData.take(1)[0])
# View the first point
print '\n{0}'.format(parsedData.take(1))

# TEST Shift labels (1d)
oldSampleFeatures = parsedDataInit.take(1)[0].features
newSampleFeatures = parsedData.take(1)[0].features
Test.assertTrue(np.allclose(oldSampleFeatures, newSampleFeatures),
                'new features do not match old features')
sumFeatTwo = parsedData.map(lambda lp: lp.features[2]).sum()
Test.assertTrue(np.allclose(sumFeatTwo, 3158.96224351), 'parsedData has unexpected values')
minYearNew = parsedData.map(lambda lp: lp.label).min()
maxYearNew = parsedData.map(lambda lp: lp.label).max()
Test.assertTrue(minYearNew == 0, 'incorrect min year in shifted data')
Test.assertTrue(maxYearNew == 89, 'incorrect max year in shifted data')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(2b) Erro quadrático médio
Para comparar a performance em problemas de regressão, geralmente é utilizado o Erro Quadrático Médio (RMSE).  Implemente uma função que calcula o RMSE a partir de um RDD de tuplas (rótulo, predição).
Can you write Python code for it?

# EXERCICIO
def squaredError(label, prediction):
    """Calculates the the squared error for a single prediction.

    Args:
        label (float): The correct value for this observation.
        prediction (float): The predicted value for this observation.

    Returns:
        float: The difference between the `label` and `prediction` squared.
    """
    return (label-prediction)**2#<COMPLETAR>

def calcRMSE(labelsAndPreds):
    """Calculates the root mean squared error for an `RDD` of (label, prediction) tuples.

    Args:
        labelsAndPred (RDD of (float, float)): An `RDD` consisting of (label, prediction) tuples.

    Returns:
        float: The square root of the mean of the squared errors.
    """
    return (labelsAndPreds.map(lambda (x,y):squaredError(x,y)).reduce(add)/labelsAndPreds.count())**(1./2)#<COMPLETAR>

labelsAndPreds = sc.parallelize([(3., 1.), (1., 2.), (2., 2.)])
# RMSE = sqrt[((3-1)^2 + (1-2)^2 + (2-2)^2) / 3] = 1.291
exampleRMSE = calcRMSE(labelsAndPreds)
print exampleRMSE

# TEST Root mean squared error (2b)
Test.assertTrue(np.allclose(squaredError(3, 1), 4.), 'incorrect definition of squaredError')
Test.assertTrue(np.allclose(exampleRMSE, 1.29099444874), 'incorrect value for exampleRMSE')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(2c) RMSE do baseline para os conjuntos de treino, validação e teste
Vamos calcular o RMSE para nossa baseline. Primeiro crie uma RDD de (rótulo, predição) para cada conjunto, e então chame a função calcRMSE.
Can you write Python code for it?

# EXERCICIO
labelsAndPredsTrain = parsedTrainData.map(lambda x: (x.label,averageTrainYear))#<COMPLETAR>
rmseTrainBase = calcRMSE(labelsAndPredsTrain)

labelsAndPredsVal = parsedValData.map(lambda x: (x.label,averageTrainYear))#<COMPLETAR>
rmseValBase = calcRMSE(labelsAndPredsVal)

labelsAndPredsTest = parsedTestData.map(lambda x: (x.label,averageTrainYear))#<COMPLETAR>
rmseTestBase = calcRMSE(labelsAndPredsTest)

print 'Baseline Train RMSE = {0:.3f}'.format(rmseTrainBase)
print 'Baseline Validation RMSE = {0:.3f}'.format(rmseValBase)
print 'Baseline Test RMSE = {0:.3f}'.format(rmseTestBase)

# TEST Training, validation and test RMSE (2c)
Test.assertTrue(np.allclose([rmseTrainBase, rmseValBase, rmseTestBase],
                            [21.305869, 21.586452, 22.136957]), 'incorrect RMSE value')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(3c) Gradiente descendente
Finalmente, implemente o algoritmo gradiente descendente para regressão linear e teste a função em um exemplo.
Can you write Python code for it?

# EXERCICIO
def linregGradientDescent(trainData, numIters):
    """Calculates the weights and error for a linear regression model trained with gradient descent.

    Note:
        `DenseVector` behaves similarly to a `numpy.ndarray` and they can be used interchangably
        within this function.  For example, they both implement the `dot` method.

    Args:
        trainData (RDD of LabeledPoint): The labeled data for use in training the model.
        numIters (int): The number of iterations of gradient descent to perform.

    Returns:
        (np.ndarray, np.ndarray): A tuple of (weights, training errors).  Weights will be the
            final weights (one weight per feature) for the model, and training errors will contain
            an error (RMSE) for each iteration of the algorithm.
    """
    # The length of the training data
    n = trainData.count()#<COMPLETAR>
    # The number of features in the training data
    #print(trainData.collect())
    #print(trainData.take(1))
    d = len(trainData.take(1)[0].features)#<COMPLETAR>
    w = np.zeros(d)
    alpha = 1.0
    # We will compute and store the training error after each iteration
    errorTrain = np.zeros(numIters)
    for i in range(numIters):
        # Use getLabeledPrediction from (3b) with trainData to obtain an RDD of (label, prediction)
        # tuples.  Note that the weights all equal 0 for the first iteration, so the predictions will
        # have large errors to start.
        labelsAndPredsTrain = trainData.map(lambda x: getLabeledPrediction(w,x))#<COMPLETAR>

        errorTrain[i] = calcRMSE(labelsAndPredsTrain)

        # Calculate the `gradient`.  Make use of the `gradientSummand` function you wrote in (3a).
        # Note that `gradient` sould be a `DenseVector` of length `d`.
        gradient = trainData.map(lambda x: gradientSummand(w,x)).reduce(add)#<COMPLETAR>
        # Update the weights
        alpha_i = alpha / (n * np.sqrt(i+1))
        w -= alpha_i*gradient
    return w, errorTrain

# create a toy...


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(3d) Treinando o modelo na base de dados
Agora iremos treinar o modelo de regressão linear na nossa base de dados de treino e calcular o RMSE na base de validação. Lembrem-se que não devemos utilizar a base de teste até que o melhor parâmetro do modelo seja escolhido.
Para essa tarefa vamos utilizar as funções linregGradientDescent, getLabeledPrediction e calcRMSE já implementadas.
Can you write Python code for it?

# EXERCICIO
numIters = 50
weightsLR0, errorTrainLR0 = linregGradientDescent(parsedTrainData,numIters)#<COMPLETAR>

labelsAndPreds = parsedValData.map(lambda x: getLabeledPrediction(weightsLR0,x))#<COMPLETAR>
rmseValLR0 = calcRMSE(labelsAndPreds)

print 'Validation RMSE:\n\tBaseline = {0:.3f}\n\tLR0 = {1:.3f}'.format(rmseValBase,
                                                                       rmseValLR0)

# TEST Train the model (3d)
expectedOutput = [22.64535883, 20.064699, -0.05341901, 8.2931319, 5.79155768, -4.51008084,
                  15.23075467, 3.8465554, 9.91992022, 5.97465933, 11.36849033, 3.86452361]
Test.assertTrue(np.allclose(weightsLR0, expectedOutput), 'incorrect value for weightsLR0')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(4b) Predição
Agora use o método LinearRegressionModel.predict() para fazer a predição de um objeto. Passe o atributo features de um LabeledPoint comp parâmetro.
Can you write Python code for it?

# EXERCICIO
samplePoint = parsedTrainData.take(1)[0]

samplePrediction = firstModel.predict(samplePoint.features)#<COMPLETAR>
print samplePrediction

# TEST Predict (4b)
Test.assertTrue(np.allclose(samplePrediction, 56.8013380112),
                'incorrect value for samplePrediction')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(4c) Avaliar RMSE
Agora avalie o desempenho desse modelo no teste de validação. Use o método predict() para criar o RDD labelsAndPreds RDD, e então use a função calcRMSE() da Parte (2b) para calcular o RMSE.
Can you write Python code for it?

# EXERCICIO
labelsAndPreds = parsedValData.map(lambda x: (x.label,firstModel.predict(x.features)))#<COMPLETAR>
rmseValLR1 = calcRMSE(labelsAndPreds)

print ('Validation RMSE:\n\tBaseline = {0:.3f}\n\tLR0 = {1:.3f}' +
       '\n\tLR1 = {2:.3f}').format(rmseValBase, rmseValLR0, rmseValLR1)

# TEST Evaluate RMSE (4c)
Test.assertTrue(np.allclose(rmseValLR1, 19.691247), 'incorrect value for rmseValLR1')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(4e) Grid Search para o valor de alfa e número de iterações
Agora, vamos verificar diferentes valores para alfa e número de iterações para perceber o impacto desses parâmetros em nosso modelo. Especificamente tente os valores  1e-5 e 10 para alpha e os valores 500 e 5 para número de iterações. Avalie todos os modelos no conjunto de valdação.  Reparem que com um valor baixo de alpha, o algoritmo necessita de muito mais iterações para convergir ao ótimo, enquanto um valor muito alto para alpha, pode fazer com que o algoritmo não encontre uma solução.
Can you write Python code for it?

# EXERCICIO
reg = bestRegParam
modelRMSEs = []

for alpha in (10**-5,10):#<COMPLETAR>:
    for numIters in (500,5):#<COMPLETAR>:
        model = LinearRegressionWithSGD.train(parsedTrainData, numIters, alpha,
                                              miniBatchFrac, regParam=reg,
                                              regType='l2', intercept=True)
        labelsAndPreds = parsedValData.map(lambda lp: (lp.label, model.predict(lp.features)))
        rmseVal = calcRMSE(labelsAndPreds)
        print 'alpha = {0:.0e}, numIters = {1}, RMSE = {2:.3f}'.format(alpha, numIters, rmseVal)
        modelRMSEs.append(rmseVal)

# TEST Vary alpha and the number of iterations (4e)
expectedResults = sorted([56.969705, 56.892949, 355124752.221221])
Test.assertTrue(np.allclose(sorted(modelRMSEs)[:3], expectedResults), 'incorrect value for modelRMSEs')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
(5b) Construindo um novo modelo
Agora construa um novo modelo usando esses novos atributos. Repare que idealmente, com novos atributos, você deve realizar um novo Grid Search para determinar os novos parâmetros ótimos, uma vez que os parâmetros do modelo anterior não necessariamente funcionarão aqui.
Para este exercício, os parâmetros já foram otimizados.
Can you write Python code for it?

# EXERCICIO
numIters = 500
alpha = 1.0
miniBatchFrac = 1.0
reg = 1e-10

modelInteract = LinearRegressionWithSGD.train(trainDataInteract, numIters, alpha,
                                              miniBatchFrac, regParam=reg,
                                              regType='l2', intercept=True)
#labelsAndPreds = parsedValData.map(lambda lp: (lp.label, model.predict(lp.features)))
labelsAndPredsInteract = valDataInteract.map(lambda lp: (lp.label, modelInteract.predict(lp.features)))#<COMPLETAR>
rmseValInteract = calcRMSE(labelsAndPredsInteract)

print ('Validation RMSE:\n\tBaseline = {0:.3f}\n\tLR0 = {1:.3f}\n\tLR1 = {2:.3f}\n\tLRGrid = ' +
       '{3:.3f}\n\tLRInteract = {4:.3f}').format(rmseValBase, rmseValLR0, rmseValLR1,
                                                 rmseValLRGrid, rmseValInteract)

# TEST Build interaction model (5b)
Test.assertTrue(np.allclose(rmseValInteract, 15.6894664683), 'incorrect value for rmseValInteract')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
Part 2: Criando o modelo de baseline
(2a) Rótulo médio
O baseline é útil para verificarmos que nosso modelo de regressão está funcionando. Ele deve ser um modelo bem simples que qualquer algoritmo possa fazer melhor.
Um baseline muito utilizado é fazer a mesma predição independente dos dados analisados utilizando o rótulo médio do conjunto de treino. Calcule a média dos rótulos deslocados para a base de treino, utilizaremos esse valor posteriormente para comparar o erro de predição.  Use um método apropriado para essa tarefa, consulte o RDD API.
Can you write Python code for it?

# EXERCICIO
from operator import add
#print (parsedTrainData.collect())
#averageTrainYear = (parsedTrainData.map(lambda x: (x.label,1)).reduce(lambda ((y1,y2),(z1,z2)):(y1+z1,y2+z2)))
#averageTrainYear = (parsedTrainData.map(lambda x: (x.label,1)))#.reduce(lambda y:1))

averageTrainYear = (parsedTrainData.map(lambda x: x.label).reduce(add))/parsedTrainData.count()
#                    .<COMPLETAR>
#                    .<COMPLETAR>
#                   )
print averageTrainYear

# TEST Average label (2a)
Test.assertTrue(np.allclose(averageTrainYear, 53.9316700801),
                'incorrect value for averageTrainYear')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
Parte 3: Treinando e avaliando o modelo de regressão linear
 (3a) Gradiente do erro
Vamos implementar a regressão linear através do gradiente descendente.
Lembrando que para atualizar o peso da regressão linear fazemos: $$ \scriptsize \mathbf{w}_{i+1} = \mathbf{w}_i - \alpha_i \sum_j (\mathbf{w}_i^\top\mathbf{x}_j  - y_j) \mathbf{x}_j \,.$$ onde $ \scriptsize i $ é a iteração do algoritmo, e $ \scriptsize j $ é o objeto sendo observado no momento.
Primeiro, implemente uma função que calcula esse gradiente do erro para certo objeto: $ \scriptsize (\mathbf{w}^\top \mathbf{x} - y) \mathbf{x} \, ,$ e teste a função em dois exemplos. Use o método DenseVector dot para representar a lista de atributos (ele tem funcionalidade parecida com o np.array()).
Can you write Python code for it?

from pyspark.mllib.linalg import DenseVector

# EXERCICIO
def gradientSummand(weights, lp):
    """Calculates the gradient summand for a given weight and `LabeledPoint`.

    Note:
        `DenseVector` behaves similarly to a `numpy.ndarray` and they can be used interchangably
        within this function.  For example, they both implement the `dot` method.

    Args:
        weights (DenseVector): An array of model weights (betas).
        lp (LabeledPoint): The `LabeledPoint` for a single observation.

    Returns:
        DenseVector: An array of values the same length as `weights`.  The gradient summand.
    """
    return (weights.dot(lp.features)-lp.label)*lp.features#<COMPLETAR>

exampleW = DenseVector([1, 1, 1])
exampleLP = LabeledPoint(2.0, [3, 1, 4])

summandOne = gradientSummand(exampleW, exampleLP)
print summandOne

exampleW = DenseVector([.24, 1.2, -1.4])
exampleLP = LabeledPoint(3.0, [-1.4, 4.2, 2.1])
summandTwo = gradientSummand(exampleW, exampleLP)
print summandTwo

# TEST Gradient summand (3a)
Test.assertTrue(np.allclose(summandOne, [18., 6., 24.]), 'incorrect value for summandOne')
Test.assertTrue(np.allclose(summandTwo, [1.7304,-5.1912,-2.5956]), 'incorrect value for summandTwo')


I am working on the file "ATIVIDADE3/.ipynb_checkpoints/Lab4a_regressao_linear-checkpoint.ipynb".
The first task is:
Parte 5: Adicionando atributos não-lineares
 (5a) Interações par a par
Conforme mencionado em aula, os modelos de regressão linear conseguem capturar as relações lineares entre os atributos e o rótulo. Porém, em muitos casos a relação entre eles é não-linear.
Uma forma de resolver tal problema é criando mais atributos com características não-lineares, como por exemplo a expansão quadrática dos atributos originais. Escreva uma função twoWayInteractions que recebe um  LabeledPoint e gera um novo LabeledPoint que contém os atributos antigos e as interações par a par entre eles. Note que um objeto com 3 atributos terá nove interações ( $ \scriptsize 3^2 $ ) par a par.
Para facilitar, utilize o método itertools.product para gerar tuplas para cada possível interação. Utilize também np.hstack para concatenar dois vetores.
Can you write Python code for it?

# EXERCICIO
import itertools

def twoWayInteractions(lp):
    """Creates a new `LabeledPoint` that includes two-way interactions.

    Note:
        For features [x, y] the two-way interactions would be [x^2, x*y, y*x, y^2] and these
        would be appended to the original [x, y] feature list.

    Args:
        lp (LabeledPoint): The label and features for this observation.

    Returns:
        LabeledPoint: The new `LabeledPoint` should have the same label as `lp`.  Its features
            should include the features from `lp` followed by the two-way interaction features.
    """
    newfeats = list(itertools.product(lp.features,repeat=2))#<COMPLETAR>
    return LabeledPoint(lp.label, list(lp.features) + map(lambda x:x[0]*x[1],newfeats))#<COMPLETAR>)
    #return lp

print twoWayInteractions(LabeledPoint(0.0, [2, 3]))

# Transform the existing train, validation, and test sets to include two-way interactions.
trainDataInteract = parsedTrainData.map(twoWayInteractions)
valDataInteract = parsedValData.map(twoWayInteractions)
testDataInteract = parsedTestData.map(twoWayInteractions)

# TEST Add two-way interactions (5a)
twoWayExample = twoWayInteractions(LabeledPoint(0.0, [2, 3]))
Test.assertTrue(np.allclose(sorted(twoWayExample.features),
                            sorted([2.0, 3.0, 4.0, 6.0, 6.0, 9.0])),
                'incorrect features generatedBy twoWayInteractions')
twoWayPoint = twoWayInteractions(LabeledPoint(1.0, [1, 2, 3]))
Test.assertTrue(np.allclose(sorted(twoWayPoint.features),
                            sorted([1.0,2.0,3.0,1.0,2.0,3.0,2.0,4.0,6.0,3.0,6.0,9.0])),
                'incorrect features generated by twoWayInteractions')
Test.assertEquals(twoWayPoint.label, 1.0, 'incorrect label generated by twoWayInteractions')
Test.assertTrue(np.allclose(sum(trainDataInteract.take(1)[0].features), 40.821870576035529),
                'incorrect features in trainDataInteract')
Test.assertTrue(np.allclose(sum(valDataInteract.take(1)[0].features), 45.457719932695696),
               ...