I am working on the file "Chapter1/Chapter1.ipynb".
The first task is:
Graphing Extras
Two packages worth exploring for visualization are:
 * Seaborn: builds on top of matplotlib and provides better defaults and some higher-level graphing functions.
 * Bokeh: uses a client-server architecture to allow easy interaction with graphs.
Both of these work in notebooks.  The easiest way to get start is to import seaborn, which improves your defaults.
Can you write Python code for it?

import seaborn as sns

z = dr12q['Z_VI']
r = dr12q['PSFMAG_2']
i = dr12q['PSFMAG_3']

fig, ax = plt.subplots(figsize=(5, 3.75))
scatter_contour(z, r - i, threshold=1000, log_counts=True, ax=ax,
                histogram2d_args=dict(bins=40),
                plot_args=dict(marker=',', linestyle='none', color='black'),
                contour_args=dict(cmap=plt.cm.bone))

ax.set_xlim(0, 5)
ax.set_ylim(-0.5, 1.0)

ax.set_xlabel(r'${\rm redshift}$')
ax.set_ylabel(r'${\rm r-i}$')

plt.show()


I am working on the file "Chapter1/Chapter1.ipynb".
The first task is:
Read the DR12 quasar catalog:
Can you write Python code for it?

quasar_catalog = bossdata.meta.Database(quasar_catalog=True)

dr12q = quasar_catalog.select_all(what='RA,DEC,Z_VI,PSFMAG_2,PSFMAG_3', max_rows=0)
z = dr12q['Z_VI']
r = dr12q['PSFMAG_2']
i = dr12q['PSFMAG_3']

fig, ax = plt.subplots(figsize=(5, 3.75))
ax.plot(z, r - i, marker='.', markersize=2, linestyle='none', color='black')

ax.set_xlim(0, 5)
ax.set_ylim(-0.5, 1.0)

ax.set_xlabel(r'${\rm redshift}$')
ax.set_ylabel(r'${\rm r-i}$')

plt.show()


I am working on the file "Chapter1/Chapter1.ipynb".
The first task is:
Use the same technique to plot the r-i vs. redshift quasar plot above:
Can you write Python code for it?

z = dr12q['Z_VI']
r = dr12q['PSFMAG_2']
i = dr12q['PSFMAG_3']

fig, ax = plt.subplots(figsize=(5, 3.75))
scatter_contour(z, r - i, threshold=1000, log_counts=True, ax=ax,
                histogram2d_args=dict(bins=40),
                plot_args=dict(marker=',', linestyle='none', color='black'),
                contour_args=dict(cmap=plt.cm.bone))

ax.set_xlim(0, 5)
ax.set_ylim(-0.5, 1.0)

ax.set_xlabel(r'${\rm redshift}$')
ax.set_ylabel(r'${\rm r-i}$')

plt.show()


I am working on the file "Chapter11.ipynb".
The first task is:
11.1.1 k-means++ 法
Can you write Python code for it?

plt.scatter(X[y_km == 0, 0],   # グラフのxの値
            X[y_km == 0, 1],   # グラフのyの値
            s=50,              # プロットのサイズ
            c='lightgreen',    # プロットの色
            marker='s',        # マーカーの形
            label='cluster 1') # ラベル名
plt.scatter(X[y_km == 1, 0],
            X[y_km == 1, 1],
            s=50,
            c='orange',
            marker='o',
            label='cluster 2')
plt.scatter(X[y_km == 2, 0],
            X[y_km == 2, 1],
            s=50,
            c='lightblue',
            marker='v',
            label='cluster 3')
plt.scatter(km.cluster_centers_[:, 0],
            km.cluster_centers_[:, 1],
            s=250,
            marker='*',
            c='red',
            label='centroids')
plt.legend()
plt.grid()
plt.show()


I am working on the file "Chapter11.ipynb".
The first task is:
11.1.2 ハードクラスタリングとソフトクラスタリング
11.1.1 エルボー法を使ってクラスタの最適な個数を求める
Can you write Python code for it?

# 歪み(SSE)の値を取得
print('Distortion: {:.2f}'.format(km.inertia_))

distortions = []
for i in range(1, 11):
    km = KMeans(n_clusters=i,    # クラスタの個数
                init='k-means++', # k-measn++ 法によりクラスタ中心を選択
                n_init=10,       # 異なるセントロイドの初期値を用いた実行回数
                max_iter=300,    # 最大イテレーション回数
                random_state=0)
    km.fit(X)
    distortions.append(km.inertia_)

plt.plot(range(1, 11), distortions, marker='o')
plt.xlabel('Number of clusters')
plt.ylabel('Distortion')
plt.show()


I am working on the file "Chapter11.ipynb".
The first task is:
11.2.1 距離行列で階層的クラスタリングを実行する
Can you write Python code for it?

from scipy.spatial.distance import pdist, squareform
# pdist で距離を計算、squareform で対称行列を作成
row_dist = pd.DataFrame(squareform(pdist(df, metric='euclidean')),
                        columns=labels, index=labels)
row_dist

from scipy.cluster.hierarchy import linkage
row_clusters = linkage(df.values, method='complete', metric='euclidean')
# 1、2列目は最も類似度が低いメンバー
# distanceはそれらのメンバーの距離
# 4列目は各クラスタのメンバーの個数
pd.DataFrame(row_clusters,
             columns=['row label 1', 'row label 2', 'distance', 'no. of items in clus.'],
             index=['cluster {}'.format(i + 1) for i in range(row_clusters.shape[0])])

# 樹形図を表示
from scipy.cluster.hierarchy import dendrogram
import matplotlib.pyplot as plt

row_dendr = dendrogram(row_clusters, labels=labels)
plt.ylabel('Euclidean distance')
plt.show()


I am working on the file "Chapter11.ipynb".
The first task is:
11.3 DBSCANを使って高密度の領域を特定する

DBSCAN(Density-based Spatial Clustering of Applications with Noise)
コア点(core point)
ボーダー点(border point)
ノイズ点(noise point)
Can you write Python code for it?

from sklearn.datasets import make_moons
X, y = make_moons(n_samples=200, noise=0.05, random_state=0)
plt.scatter(X[:, 0], X[:, 1])
plt.show()

f, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))

# k-means 法で分類してプロット
km = KMeans(n_clusters=2, random_state=0)
y_km = km.fit_predict(X)
ax1.scatter(X[y_km == 0, 0], X[y_km == 0, 1],
            c='lightblue', marker='o', s=40, label='cluster 1')
ax1.scatter(X[y_km == 1, 0], X[y_km == 1, 1],
            c='red', marker='s', s=40, label='cluster 2')

ax1.set_title('K-means clustering')

# 完全連結法法で分類してプロット
from sklearn.cluster import AgglomerativeClustering
ac = AgglomerativeClustering(n_clusters=2,
                             affinity='euclidean',
                             linkage='complete')
y_ac = ac.fit_predict(X)
ax2.scatter(X[y_ac == 0, 0], X[y_ac == 0, 1], c='lightblue',
            marker='o', s=40, label='cluster 1')
ax2.scatter(X[y_ac == 1, 0], X[y_ac == 1, 1], c='red',
            marker='s', s=40, label='cluster 2')
ax2.set_title('Agglomerative clustering')

plt.legend()
plt.show()

from sklearn.cluster import DBSCAN

db = DBSCAN(eps=0.2, min_samples=5, metric='euclidean')
y_db = db.fit_predict(X)
plt.scatter(X[y_db == 0, 0], X[y_db == 0, 1],
            c='lightblue', marker='o', s=40,
            label='cluster 1')
plt.scatter(X[y_db == 1, 0], X[y_db == 1, 1],
            c='red', marker='s', s=40,
            label='cluster 2')
plt.legend()
plt.show()


I am working on the file "Chapter13.ipynb".
The first task is:
13.1.3 Theano を設定する
Can you write Python code for it?

# 浮動小数点数の型のデフォルトを確認
print(theano.config.floatX)

# 浮動小数点数の型を float32 に設定
# GPU の場合は float32 にしないといけないらしい
theano.config.floatX = 'float32'

# CPU と GPU どっちを使うかの設定を確認
print(theano.config.device)


I am working on the file "Chapter13.ipynb".
The first task is:
13.2 フィードフォワードニューラルネットワークでの活性化関数の選択
13.2.1 ロジスティック関数のまとめ
Can you write Python code for it?

import numpy as np

X = np.array([[1, 1.4, 1.5]])
w = np.array([0.0, 0.2, 0.4])

def net_input(X, w):
    z = X.dot(w)
    return z

def logistic(z):
    return 1.0 / (1.0 + np.exp(-z))

def logistic_activation(X, w):
    z = net_input(X, w)
    return logistic(z)
print('P(y=1|x) = {:.3f}'.format(logistic_activation(X, w)[0]))

# W : array, shape = [n_output_units, n_hidden_units+1]
# 隠れ層 -> 出力層の重み行列
# 最初の列 (W[:][0]) がバイアスユニットであることに注意
W = np.array([[1.1, 1.2, 1.3, 0.5],
              [0.1, 0.2, 0.4, 0.1],
              [0.2, 0.5, 2.1, 1.9]])

# A : array, shape = [n_hidden+1, n_samples]
# 各礼装の活性化
# 最初の要素 (A[0][0] = 1) がバイアスユニットであることに注意

A = np.array([[1.0],
              [0.1],
              [0.3],
              [0.7]])

# Z : array, shape = [n_output_units, n_samples]
# 出力層の総入力

Z = W.dot(A)
y_probas = logistic(Z)
print('Probabilities:\n', y_probas)

y_class = np.argmax(Z, axis=0)
print('predicted class label: %d' % y_class[0])


I am working on the file "Chapter13.ipynb".
The first task is:
13.2.2 ソフトマックス関数を使って多クラス分類の確率を推定する
Can you write Python code for it?

def softmax(z):
    return np.exp(z) / np.sum(np.exp(z))

def sotmax_activation(X, w):
    z = net_input(X, w)
    return softmax(z)

y_probas = softmax(Z)
print(y_probas)
print(y_probas.sum())

y_class = np.argmax(Z, axis=0)
y_class[0]


I am working on the file "Chapter13.ipynb".
The first task is:
Mac でバックエンドを theano にするために ~/.keras/keras.json を書き換える
参考: バックエンド - Keras Documentation
Can you write Python code for it?

from keras.utils import np_utils

print('First 3 labels: ', y_train[:3])

y_train_ohe = np_utils.to_categorical(y_train)
print('\nFirst 3 labels (one-hot):\n', y_train_ohe[:3])

from keras.models import Sequential
from keras.layers.core import Dense
from keras.optimizers import SGD

np.random.seed(1)

# モデルを初期化
model = Sequential()

# 1つ目の隠れ層を追加
model.add(Dense(input_dim=X_train.shape[1], # 入力ユニット数
                output_dim=50, # 出力ユニット数
                init='uniform', # 重みを一様乱数で初期化
                activation='tanh')) # 活性化関数(双曲線正接関数)

# 2つ目の隠れ層を追加
model.add(Dense(input_dim=50,
                output_dim=50,
                init='uniform',
                activation='tanh'))

# 出力層を追加
model.add(Dense(input_dim=50,
                output_dim=y_train_ohe.shape[1],
                init='uniform',
                activation='softmax'))

# モデルコンパイル時のオプティマイザを設定
# SGD: 確率的勾配降下法
# 引数に学習率、荷重減衰定数、モーメンタム学習を設定
sgd = SGD(lr=0.001, decay=1e-7, momentum=.9)
# モデルをコンパイル
model.compile(loss='categorical_crossentropy', # コスト関数
              optimizer=sgd, # オプティマイザ
              metrics=['accuracy']) # モデルの評価指標

model.fit(X_train, # トレーニングデータ
          y_train_ohe, # 出力データ
          nb_epoch=50, # エポック数
          batch_size=300, # バッチサイズ
          verbose=1,  # 実行時にメッセージを出力
          validation_split=0.1) # 検証用データの割合

y_train_pred = model.predict_classes(X_train, verbose=0)
print('First 3 predictions: ', y_train_pred[:3])

train_acc = np.sum(y_train == y_train_pred, axis=0) / X_train.shape[0]
print('Training accuracy: %.2f%%' % (train_acc * 100))

y_test_pred = model.predict_classes(X_test, verbose=0)
test_acc = np.sum(y_test == y_test_pred, axis=0) / X_test.shape[0]
print('Test accuracy: %.2f%%' % (test_acc * 100))


I am working on the file "Chapter13.ipynb".
The first task is:
双曲線正接関数を使って出力範囲を拡大する

双曲線正接関数(hyperbolic tangent: tanh)

13.3 Kerasを使ったニューラルネットワークの効率的なトレーニング
pip install Keras

MNIST データセット http://yann.lecun.com/exdb/mnist/
train-images-idx3-ubyte.gz: training set images (9,912,422 bytes)
train-labels-idx1-ubyte.gz: training set labels (28,881 bytes)
t10k-images-idx3-ubyte.gz: test set images (1,648,877 bytes)
t10k-labels-idx1-ubyte.gz: test set labels (4,542 bytes)
Can you write Python code for it?

import os
import struct
import numpy as np

def load_mnist(path, kind='train'):
    """Load MNIST data from `path`"""
    labels_path = os.path.join(path,
                               '%s-labels-idx1-ubyte' % kind)
    images_path = os.path.join(path,
                               '%s-images-idx3-ubyte' % kind)

    with open(labels_path, 'rb') as lbpath:
        magic, n = struct.unpack('>II',
                                 lbpath.read(8))
        labels = np.fromfile(lbpath,
                             dtype=np.uint8)

    with open(images_path, 'rb') as imgpath:
        magic, num, rows, cols = struct.unpack(">IIII",
                                               imgpath.read(16))
        images = np.fromfile(imgpath,
                             dtype=np.uint8).reshape(len(labels), 784)

    return images, labels

X_train, y_train = load_mnist('mnist', kind='train')
print('Rows: %d, columns: %d' % (X_train.shape[0], X_train.shape[1]))

X_test, y_test = load_mnist('mnist', kind='t10k')
print('Rows: %d, columns: %d' % (X_test.shape[0], X_test.shape[1]))

import theano

theano.config.floatX = 'float32'
X_train = X_train.astype(theano.config.floatX)
X_test = X_test.astype(theano.config.floatX)


I am working on the file "Chapter13.ipynb".
The first task is:
環境変数で設定の変更が可能

export THEANO_FLAGS=floatX=float32

cpuを使って計算する場合

THEANO_FLAGS=device=cpu,floatX=float64 python <pythonスクリプト>

gpuを使う場合

THEANO_FLAGS=device=gpu,floatX=float32 python <pythonスクリプト>

~/.theanorc ファイルにデフォルト設定を書くことも可能

[global]
floatX=float32
device-gpu
13.1.4 配列構造を操作する
Can you write Python code for it?

import numpy as np

# 初期化
# Theanoを64ビットモードで実行している場合は、fmatrixの代わりにdmatrixを使用する必要がある
x = T.fmatrix(name='x')
x_sum = T.sum(x, axis=0)

# コンパイル
calc_sum = theano.function(inputs=[x], outputs=x_sum)

# 実行(Pythonリスト)
ary = [[1, 2, 3], [1, 2, 3]]
print('Column sum:', calc_sum(ary))

# 実行(Numpy配列)
ary = np.array([[1, 2, 3], [1, 2, 3]], dtype=theano.config.floatX)
print('Column sum:', calc_sum(ary))

import theano
from theano import tensor as T

# 初期化
x = T.fmatrix('x')
w = theano.shared(np.asarray([[0.0, 0.0, 0.0]], dtype=theano.config.floatX))
z = x.dot(w.T)
update = [[w, w + 1.0]]

# コンパイル
net_input = theano.function(inputs=[x], updates=update, outputs=z)

# 実行
data = np.array([[1, 2, 3]], dtype=theano.config.floatX)
for i in range(5):
    print('z{}:'.format(i), net_input(data))

import theano
from theano import tensor as T

# 初期化
data = np.array([[1, 2, 3]], dtype=theano.config.floatX)
x = T.fmatrix('x')
w = theano.shared(np.asarray([[0.0, 0.0, 0.0]], dtype=theano.config.floatX))
z = x.dot(w.T)
update = [[w, w + 1.0]]

# コンパイル
net_input = theano.function(inputs=[], updates=update, givens={x: data}, outputs=z)

# 実行
for i in range(5):
    print('z{}:'.format(i), net_input())


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
A interpretação dum pedaço de código, pelo interpretador, é um processo complexo, que requer duas fases. Numa primeira fase o sistema verifica a sintaxe da expressão. Validando se a sequência de símbolos que constituem as linhas de código, fazem sentido. Na segunda fase, o sistema avalia o código. Genericamente a avaliação dum pedaço de código, leva a uma alteração do estado da memória do computador. Podendo resultar na produção de um resultado, como nos exemplos anteriores.
Por exemplo, na célula abaixo, temos uma sequência de símbolos que descrevem uma expressão aritmética, que é sintaticamente correta:
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Acima são apresentados dois exemplos de expressões que, com os nossos conhecimentos de aritmética, não sabemos avaliar. De forma idêntica não respeitam as regras da linguagem de programação. O Interpretador gera nestes casos um erro. Este tipo de erro é usualmente designados de erros de sintaxe, alertando que o código não pode ser executada.
Os arguementos dos operadores e o resultado  de avaliar as fórmulas anteriores são valores numéricos. Estes valore são codificados por cadeias de dígitos, que o sistema (e nós)  interpretamos como números. Estas cadeias são em Python designadas de constantes literais.
Constantes Literais
Como exemplos de constantes literais usados acima temos 2 e 3. Mas poderíamos ter usado 32. O mundo não vive apenas de números, temos necessidade de palavras para descrever as coisas. Qualquer cadeia de símbolos como 'Isto é fantástico!', que corresponde a uma sequência de palavras em Português, é considerado também pelo interpretador como uma constante literal. Estas cadeias de símbolos em programação são genericamente designadas de strings, entendidas como sequência de caracteres.
Outros exemplos de constantes literais são 1.23 ou 9.25e-3. Por exemplos de strings temos 'Isto é uma string' ou "É uma string!". Estas identidades dizem-se constantes porque o seu significado não varia com o contexto da interpretação do código. São constantes literais porque devem ser interpretadas à letra (literalmente) pelo ser humano.
Genericamente as constantes literais são classificadas em duas categorias, ou representam números, ou são strings.
Números
Os números em Python podem ser de três tipos: inteiros, ponto flutuante e complexos:

2 é um exemplo de inteiro, os inteiros são elementos do conjunto dos números inteiros. Existem no entanto limitações à magnitude dos inteiros que se podem usar.

3.23 e 52.3E-4 são exemplos de números décimais ou no sistema de virgula flutuante (ou floats, para abreviar). No segundo caso o símbolo E indica uma potência de 10. Neste caso, 52.3E-4 representa o número...
Can you write Python code for it?

'O estudo da lógica remonta à civilização helénica'


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Adicione à função uma \emph{string} de documentação. Execute:
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Agora só temos um bloco-if com  duas instruções. O último print é executado porque a condição só controla a execução das duas intruções que estão no bloco.
Can you write Python code for it?

x=1

if x>2:
    print(10*'.^.')
print('O número é maior que 2.')
print(10*'\'v\'')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Agora, como a condição contínua a ser falsa, as três instruções do bloco não são executadas. Neste caso não é produzido nenhum output.
Um pouco mais abaixo pode encontrar um exemplo mais realista. Chamámos a esse programa "Descobre o número". O que ela faz é referenciar um inteiro e pede ao utilizador para o descobrir. A necessidade de pedir informação para contínuar a execução de um programa exige a introdução duma novas função. Na vedade neste exemplo vai poder facilmente identificar duas novas funções, a utilização de um novo operador relacional e uma nova sintaxe para o comando if. As novas funções são input e int, a nova relação é ==.
A função input tem por argumento uma string e devolve uma string. Isto define a assinatura da função e temos por hábito escrever input:str->str, para significar que entra uma string e sai uma string. A string que serve de argumento é usada como prompt, ou seja título de uma pergunta feita pelo interpretador ao utilizador. A reposta do utilizador deve ser uma sequência de símbolos, que é aceite pelo sistema quando é carregada na tecla de ENTER (ou seja RETURN). Sendo a cadeia transformada numa string, de é devolvida como output pela função:
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Aqui fica o exemplo mais completo. Note que na célula existem linhas com texto que começam com # (cardinal). O texto que precede # é usualmente designado por comentário, não sendo executado pelo interpretador. Os comentários tentam tornar a implementação mais clara. Têm por principal objectivo tornar o código mais claro.
Can you write Python code for it?

#
# Programa descobe o número que está referênciado em memória
#

numero = 23 # este é o número que tentamos descobrir

hipotese = int(input('Qual é o número inteiro? '))

if hipotese == numero:
    print('Parabéns, você acertou.') # Novo bloco começa aqui
    print('Tenha um bom dia...') # Novo bloco termina aqui
elif hipotese < numero:
    print('Não, é maior que isso.')  # Outro bloco
    # O bloco pode conter uma ou mais linhas ...
else:
    print('Não, é menor que isso.')

print('Adeus.')
# Esta última instrução é sempre executada, depois da instrução if
# ser executada


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Aqui podemos entender o anterior programa, como tendo três linhas de código. Na primeira linha definimos x como sendo 2. Na segunda linha definimos y como sendo 3. Na terceira linha imprimimos o valor da interpretação de x+y.
Na maioria das linguagens de programação a descrição acima é suficiente para se entender as linhas de código. No entanto em Python devíamos dizer que com x=2 queremos que x referência a constante literal 2. Neste sentido x+y opera as constantes referenciadas por x e y. O operador = é designado de operador de atribuição. Devemos no entanto notar que, = em programação, não têm exatamente o mesmo sentido que está habituado em Matemática. Em matemática = significa igualdade ou seja é uma relação binária. É isto que lhe permite dizer que 2=1 é falso. Contudo quando escreve x=2, numa equação quer dizer que, assumindo a relação verdadeira, então o valor da variável x é igual a 2. O que se aproxima do significado de uma atribuição numa linguagem de programação.
Executando a próxima célula:
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
As variáveis podem assim ser usadas para referenciar qualquer constante literal. Facilitando o seu tratamento e manipulação.
De forma genérica, aqui, uma  variável pode ser entendida como uma referência a uma parte da memória do computador onde está armazenada informação. Diferindo das constantes literais, uma vez que o seu significado pode variar no decurso da execução dum programa.
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Caso se escolha outro delimitador de string este problema pode ser ultrapassado.
Can you write Python code for it?

print("Why was logic considered to be fundamental to one's education?")


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Como está escrita numa única linha, é entendida como uma linha física.
Implicitamente, Python incentiva o uso de uma única instrução por linha, com o propósito de tornar o código mais legível.
Se pretende definir mais do que uma linha lógica numa única linha física, então deve separar as linhas lógicas através de um ponto-e-virgula (';') para indicar o fim de cada linha lógica ou instrução. Por exemplo,
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Como indicado na mensagem de erro, não pode avaliar a expressão porque z não está definido. O interpretador reconhece x, porque foi definido na célula anterior, mas z é a primeira vez que é usado.
Muito Importante: Sempre que define uma variável esta fica disponível na execução de qualquer célula que definir posteriormente.
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Como já tinhamos referido, comparamos objetos usando operadores relacionais. Já usamos os operadores < e >, que lhe são famíliares da matemática e que interpreta como menor e maior. Por <= e >= o interpretador identifica menor ou iguel e maior ou igual. Já a igualdade de objeto é codificada por ==, por forma a o distinguir do operador de atribuição. Já a relação diferente é codificada por != ou <>.
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Em cada um dos exemplos, quando a célula é executada, é apresentado uma representação das avaliações dos argumentos da função print. Que, como vimos, pode diferir da representação feita pelo interpretador.
Sequências de Escape
Existem várias sequências de escape, para além das duas que apresentámos anteriormente.
Recordando: Para definir uma string que contenha um apóstrofe ('), podemos fazer:
Can you write Python code for it?

print('Why was logic considered to be fundamental to one\'s education?')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Este é o processo mais comum para as representar. As outras formas de descrever tentam apenas facilitar o trabalho dum programados.
Aspas Duplas
Assim as strings podem também ser definidas usando aspas duplas por exemplo:
Can you write Python code for it?

"A arte da argumentação levou à morte de Sócrates."


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Exercício:
Identifique os erros de sintaxe na definição da função abaixo:
Can you write Python code for it?

def codigoErrado(x):
    Return X**2 - 1


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Existem outras sequências de escape, apresenta-se aqui apenas as mais usadas. Para um descrição sistemática use a documentação do interpretador, em https://www.python.org/.
Num editor, durante a programação, é frequente ter a necessidade de continuar uma string na linha imediatamente abaixo. Para isso é usada uma única barra invertida no fim da linha. Por exemplo para escrever Looking Glass de Lewis Carroll, com um único print, podemos fazer:
Can you write Python code for it?

print("\"Reciprocamente\", continuou Tweedledee, \
\"Se é assim, ele pode ser, \n \
e se não é, será; mas como não é não se preocupa. \
Isto é lógica.\" ")


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Já apresentamos operadores que podem ser usados para operar valores numéricos. Existem também operadores que podemos usar nas strings.
Concatenação de Literais do Tipo String
Quando numa linha de código duas strings são postas lado a lado, o interpretador faz a sua concatenação, ou seja, cria uma nova string que é formada juntando sucessivamente as várias strings. Por exemplo:
Can you write Python code for it?

print('Originalmente' ' a lógica lidava' ' com linguagem natural')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Na tentativa de avaliar uma expressão, como a anterior, o Python, guiado pela ordem de precedência imposta pelos operadores ou pela parentização, avalia progressivamente sub-fórmulas até obter um valor único.
<img src="000056.png" width = 200/>
As regras usadas para formar expressões que podem ser avaliadas ( ou que o interpretador de Python perceba) descrevem a gramática desta linguagem de programação. Neste livro não vamos fazem uma descrição detalhada da gramática da linguagem de programação, no entanto vamos apresentar alguns fragmentos da linguagem. O último Capítulo do livro é dedicado a uma descrição formal do que se entende por gramática de uma linguagem.
Sempre que pedimos ao Python para executar uma instrução desconhecida, ou cuja descrição é incorreta não respeitando a gramática da linguagem Python, é emitida uma mensagem identificando um erro de sintaxe. Levando isto que o código não seja avaliado pelo sistema.
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Neste programa, é inquirido o utilizador por um número inteiro e é verificado se este é igual a um número escondido.
É obvio que o exemplo é patetico. Já vimos o número e no caso de termos má memória só temos uma tentativa. Na verdade, fora do Jupyter, o utilizador não tem acesso directo ao código, o que torna o exemplo mais "realista". Vaí ter de contínuar a ter de executar o programa várias vezes até resolver o puzzle.
No programa são usadas duas variáveis numero e hipotese. Usa-se a variável numero para referenciar o inteiro a adivinhar, neste caso number = 23. O utilizador tem apenas uma tentativa para adivinhar o número. A hipótese do utilizador é feita através da função input() que acabamos de descrever. Que será referenciada pela variável hipotese. Para isso, a função input, cria uma prompt  e espera até que o utilizador escreva uma cadeia de caracteres e tecle ENTER (ou RETURN).  A string que o utilizador fornece é usada como valor devolvido pela função. A função int, converte essa string para um inteiro, passado a ser referenciado pela variável hipotese.
Em seguida, é comparado o inteiro referenciado pela variável hipotese com o número referenciado por numero.Se eles forem iguais, imprime-se uma mensagem a felicitar o utilizador. Note que, são utilizados níveis de identação para informar o interpretador de Python que a sequência de instruções pertence a um bloco.
Caso a tentativa do utilizador seja menor que o número referenciado pela variável numero, informa-se que tente na próxima execução  um número maior que o número da presente tentativa. Usa-se aqui uma cláusula elif para reduz a quantidade de identações requeridas por estas duas condições.  É neste sentido que dizemos que agora o commando if controla agora três blocos de execução: um bloco-if que descreve o que fazer quando os números são iguais; um bloco-elif que diz o que fazer quando o número é maior; e um bloco-else que diz o que fazer caso contrário.
Após ser executada a instrução de um dos blocos (e só um), a execução passa para o...
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
No exemplo H1, H2 e H3 são usadas para identificar três strings, cuja concatenação é imprimida na shell través do comando print.
Em Python as coisas que estão armazenadas em memória e se podem referenciar por variáveis são designados de objectos. Assim, os números e as strings objetos. Os números são objetos numéricos e podem ser de três tipos inteiros, floats ou complexos. A strings são então objetos de tipo string.
O nome dado a uma variáveis é conhecido como identificador, uma vez que é o que permite identificar um objecto em memória.
Em toda a cadeia de carateres pode ser usada como identificador. Existem regras  para a sua formação. São elas:

O primeiro carater do identificador tem de ser uma letra do alfabeto (maiúsculo ASCII ou minúsculo ASCII) ou um '_'.
O resto do nome do identificador pode consistir de letras (maiúsculo ASCII ou minúsculo ASCII), '_' ou dígitos (0-9).
Nas letras usadas na construção dum identificador, uma maiúscula é diferente duma minúscula. Por exemplo, myname e myName são identificadores diferentes. Para significar isto é usual escrever que os  identificadores são \textit{case-sensitive}.

Exemplos de identificadores válidos são i, __my_name, name_23 e a1b2_c3.  Exemplos de identificadores inválidos são 2things e my-name, porque o primeiro caracter do identificador não pode ser um digito e - é um carater que não é permitido ocorer no identificador.
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
No programa começamos por usar o identificador i para referenciar a constante literal 5 através do operador de atribuição (=).  Em seguida, imprime-se o valor de i através do comando print.
Na instrução seguinte somamos 1 ao valor referenciado por i. A partir deste momento i passa a referenciar o objeto 6. Em seguida, imprime-se o valor de i, agora 6.
Como já se tinha feito na secção anterior, de forma análoga referencia-se um objeto string  pela variável s, que depois se imprime.
Assim o resultado de executar a célula são a impressão de 4 linhas de texto pelos comandos print:
5
6
Esta é uma string de múltiplas linhas.
Esta é a segunda linha.
Linhas Lógicas e Físicas
As linhas físicas são aquelas que escrevemos num linha a quando  da definição código dum programa. Uma linha lógica é a que o interpretador de Python entende por uma única instrução. O Python implicitamente assume que cada linha física corresponde a uma linha lógica.
Um exemplo de uma linha lógica é uma instrução como:
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Note que a linha da instrução if termina com ''dois pontos'' indicando que a seguir há um bloco de instruções.
Quando a condição x>2 é verdadeira é executado o bloco-if
print(10*'.^.')
    print('O número é maior que 2.')
    print(10*'\'v\'')
Sem que a condição x>2 é falsa é executado o bloco-else
print(10*'-._')
    print('O número não é maior que 2.')
    print(10*'_.-')
Alter o conteúdo da célula acima para ver as alterações do resultado da execução. Podemos assim garantir que o código a executar vai depender do valor que for referenciado pela variável x.
Como indentar os blocos
Não misturar tabulações com espaços a quando da indentação, já que nem todas as plataformas a suportam. É recomendado o uso de uma tabulação, ou dois espaços ou quatro espaços para distinguir cada nível de indentação. Escolha um destes estilos de indentação. Mais importante que a escolha que faz, deve manter-se consistente a ela, ou seja, mantenha apenas um tipo de indentação ao longo de todo o código.
Na maioria dos ambientes de programação, como nos Jupyther Notebooks, o sistema tenta ajudar no processo de indentação. Cabendo ao programador saber quando deve remover a indetação. Note nos exemplos abaixo que a identação determina o fluxo de execução.
Can you write Python code for it?

x=1

if x>2:
    print(10*'.^.')
    print('O número é maior que 2.')
print(10*'\'v\'')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Note que agora, as sequência de escape são representados pelo seu significado. Neste contexto, o texto devolvido não é identificado pelo Jupyter como o resultado da interpretação do código. O texto é agora o resultado de executar o comando print.
Assim podemos produzir o significado original:
Can you write Python code for it?

print( '''A palavra "trivial" tem uma etimologia interessante.
 É a conjugação de "tri" (significando '3') e "via" (significando caminho).
 Originalmente refere-se ao "trivium", as três áreas fundamentais do
 'curriculae': gramática, retórica e lógica.
 Assuntos que se tem de dominar para aceder ao "quadrivium", que
 consiste na aritmética, geometria, música e astronomia.''')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Note que aqui no resultado da interpretação o símbolo " foi transformado numa aspa simples '.
Aspas Triplas
Outra forma a definir strings que ocupam várias linhas é usar aspas triplas (""" ou '''). Um exemplo:
Can you write Python code for it?

 '''A palavra "trivial" tem uma etimologia interessante.
 É a conjugação de "tri" (significando '3') e "via" (significando caminho).
 Originalmente refere-se ao "trivium", as três áreas fundamentais do
 'curriculae': gramática, retórica e lógica.
 Assuntos que se tem de dominar para aceder ao "quadrivium", que
 consiste na aritmética, geometria, música e astronomia.'''


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Não existindo limite ao número de elifs. O bloco controlado por um elif só é executado caso a sua cláusula seja verdadeira e as condições que lhe estão acima sejam falsas.
Can you write Python code for it?

x = 1

if x == 0:
    print('zero')
elif x==1:
    print('um')
elif x==2:
    print('dois')
else:
    print('Não é nem zero, nem um, nem dois.')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
O objeto string que passa a ser referenciado por H deve ser entendido como definido numa única linha lógica, apesar de ocupar diferentes linhas físicas.
Neste sentido usa-se ; (ponto-e-virgula) para separar linhas lógicas na mesma linha física, enquanto $\setminus$ para separar uma linha lógica em diferentes linhas físicas.
Indentação
Os espaços em  branco no inicio duma instrução são muito importantes no Python. Na verdade, os espaços brancos no início de uma linha definem a estrutura do programa. Aqui, como é usual em qualquer processador de texto, estes espaços são designados de indentação.
A indentação do código pode ser definido por espaços ou tabulações. Um grupo de linhas consecutivas com a mesma identação é designado por bloco de código. Os blocos de código são usados para indentificar um conjunto de instruções que devem ser executadas, sequencialmente mas em conjunto, condicionada a sua execução por uma condição ou num contexto comum. É óbvio que dito isto assim é muito abstrato. Vamos já a seguir concretizar isto através de blocos controlados por condições. Deixamos os blocos executados no mesmo contexto, para o próximo capítulo.
Note que, um indentação sem nexo leva a erros de sintaxe. Por exemplo:
Can you write Python code for it?

i = 5
 print('São ', i)
print('São,',i,' os macacos.')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
O valor lógico destas expressões definem uma nova estrutura de dados, nativa do Python, usualmente designados de Booleanos ou Bool (para variar). A propósito: Sempre que quiser saber qual é o tipo dum objecto pode usar o comando type.
Can you write Python code for it?

type(1)

type(1.0)

type('uma string')

type(True)


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Operador |  Operação | Exemplo | Valor ...
---------|-----------|-------------|-----------
       | potência  | 2  3      | 8
%        | resto da divisão inteira | 22 % 8 |6
//       | quociente da divisão inteira | 22 // 8 | 2
/       | divisão |  22 / 8 | 2.75
*  | multiplicação |  3 * 5 |15
-  | subtração |  5 - 2 | 3
+  | adição  | 2 + 2 | 4
A ordem das operações, também designada de precedência dos operadores aritméticos, usado pelo interpretador de Python é similar ao que é usada na aritmética. Quando escritos em sequência, os operadores ** (potência) é avaliado primeiro; os operadores  *, /, //, e % são avaliados a seguir, da esquerda para a direita; por último é avaliado + e - (também da esquerda para a direita). Naturalmente que podemos usar parênteses para super-impor a ordem de avaliação que desejar.
Pelo descrito, a interpretação de 2+2*11//+1 é 5:
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Se por algum motivo tem necessidade que as sequências de escape, na definição da string, não sejam reescrtitas pelo comando print deve usar como prefixo um r ou um R. Por exemplo, na string anterior:
Can you write Python code for it?

print(r"\"Reciprocamente\", continuou Tweedledee, \
\"Se é assim, ele pode ser, \n \
e se não é, será; mas como não é não se preocupa. \
Isto é lógica.\" ")


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Temos assim as estruturas fundamentais:
1. int - os números inteiros
1. float - os números decimais
1. str - as cadeias de caracteres ou strings
1. bool - os valores lógicos ou booleanos
Os valores lógicos True ou False, também são constantes literárias, não nos sendo permitido alterar o seu significado. Sendo elemento fundamental para o controlo do fluxo de execução dum programa.
Estas estruturas são usadas nestes textos como as estruturas de dados primitivas. Vamos usa-las  como bloco fundamental para a construtução de estruturas mais complexas.
Controlo do fluxo de programas
Os programas que vimos até aqui, são descritos por uma série de declarações, ficando o interpretador de Python encarregue de as executar seguindo uma ordem pela qual são escritas nas células.
Como alterar o fluxo de execução? Por exemplo, se pretende que o programa tome algumas decisões e faça diferentes coisas em função de diferentes situações. Como imprimir 'Bom Dia' ou 'Boa Tarde', dependendo da hora do dia?
Isto é consumado usando as instruções de controle de fluxo no Python if, for e while, permitindo executar um ou mais blocos de instruções apenas ou enquanto uma condição for verdadeira. Neste Capítulo vamos centrar o nosso esforço no comando if.
Blocos controlados por um if
A instrução if é usada para decidir que bloco de código deve ser executado em seguida. A escolha do bloco a executar é determinado pelo valor lógico de uma condição usado como argumento do comando. Caso a condição seja verdadeira um conjunto de "instruções" é executado em detrimento de outro, que só será executado quando a condição é falsa. Estes blocos executáveis quando a condição é verdadeira é designado de  bloco-if (if-block), o bloco que é executado quando a condição é falsa é designado de  bloco-else (else-block)).
A sintaxe da instrução é apresentada de seguida. Para isso execute a célula abaixo para diferentes valores de x.
Can you write Python code for it?

x=2

if x>2:
    print(10*'.^.')
    print('O número é maior que 2.')
    print(10*'\'v\'')
else:
    print(10*'-._')
    print('O número não é maior que 2.')
    print(10*'_.-')


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Uma forma prática para repetir uma sequência de caracteres é usar o operador *. Apesar de neste contexto o operador continuar a ser binário, o primeiro argumento tem de ser um inteiro e o segundo uma string. Por exemplo para repetir 50 vezes o padrão definido pela string '---...--- ' fazemos:
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Variáveis
Como um mundo de constantes não evolui vamos aqui introduzir a noção de variável. Em si a noção não vai variar muito do que está habituado na Matemática (as variáveis duma equação). Em programação uma variável só pode ser usada tiver associado um valor.
Can you write Python code for it?


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
Voltando a um exemplo anterior:
Can you write Python code for it?

H=   "\"Reciprocamente\", continuou Tweedledee, \
\"Se é assim, ele pode ser, \n \
e se não é, será; mas como não é não se preocupa. \
Isto é lógica.\" "
print(H)


I am working on the file "Chapter1_Introducao/Chapter1_Introducao.ipynb".
The first task is:
é o mesmo que
Can you write Python code for it?


I am working on the file "Chapter1_Introduction.ipynb".
The first task is:
General Machine Learning Setup

Perform feature selection and feature extraction to get the input data;
Partition the input data into training, validation and test data;
foreach model do
Model Selection: Learn hyperparameters by optimizing model selection criterion on validation data
foreach parameter do
Model fitting/training: Learn parameters by optimizing training criterion on training data

After above process, the learned model is m and the learned parameters are p. Use test data to verify the accuracy (or some other performance measure) of the model/parameter (m; p).
To test that we are actually learning, we slowly increase the number of training datapoints (i.e. experience) and see if the performance (i.e. score) increases. As an example, we will use a simple machine learning model (i.e. logistic regression) and plot the performance vs number of training datapoints.
Recall:

A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E.
Can you write Python code for it?

%matplotlib inline
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.utils import shuffle
from systemml.mllearn import LogisticRegression
from pyspark.sql import SQLContext
sqlCtx = SQLContext(sc)
digits = datasets.load_digits()
X_digits = digits.data
y_digits = digits.target
X_digits, y_digits  = shuffle(X_digits, y_digits, random_state=0)
n_samples = len(X_digits)
X_test = X_digits[int(.8 * n_samples):]
y_test = y_digits[int(.8 * n_samples):]
training_fraction = [0.005, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
scores = []
for frac in training_fraction:
    X_train = X_digits[:int(frac * n_samples)]
    y_train = y_digits[:int(frac * n_samples)]
    classifier = LogisticRegression(sqlCtx)
    score = classifier.fit(X_train, y_train).score(X_test, y_test)
    scores = scores + [ score ]
plt.plot(training_fraction, scores)
plt.xlabel('Fraction of data used for training: E')
plt.ylabel('Prediction score (higher the better): P')
plt.show()


I am working on the file "Chapter1_Introduction.ipynb".
The first task is:
Neural networks returns
With the invention of back-propogation algorithm, research on neural networks
(which was almost stagnant due to
criticism by Marvin Minsky on Rosenblatt's perceptron) revived during 1980s.
VC Theory
From 1980 to early 1990s, Vladimir Vapnik introduced Vapnik-Chervonenkis theory (VC theory),
that attempts to explain the learning process from a statistical point of view.
The key question of this new field machine learning that was based on Vapnik's framework
was no longer Turing's grand question, but much more simple and realistic one:
"(Given enough examples) Can machine learn something about them ?":

A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P,
if its performance at tasks in T, as measured by P, improves with experience E ... by Tom Mitchell.

Here experience E refers to data (or examples), performance measure P usually refers to accuracy (or some other metrics) and
the task T refers to machine learning algorithms.
Can you write Python code for it?

from IPython.display import YouTubeVideo
YouTubeVideo('jmMcJ4XlrWM', start=195, end=234)


I am working on the file "Chapter1_Introduction.ipynb".
The first task is:
Step 2: Feature representation
Now, we convert the binary object into a format required for machine learning algorithm. This is usually (but not necessarily) a D-dimensional numeric vector (called as feature):
Can you write Python code for it?

%matplotlib inline
import matplotlib.pyplot as plt
from sklearn import datasets
digits = datasets.load_digits()
images_and_labels = list(zip(digits.images, digits.target))
for index, (image, label) in enumerate(images_and_labels[:1]):
    plt.subplot(2, 1, index + 1)
    plt.axis('off')
    plt.imshow(image, cmap=plt.cm.gray_r)
    plt.title('Feature: ' + str(image.flatten()))
plt.show()


I am working on the file "Chapter1_Introduction.ipynb".
The first task is:
The first generation of AI researchers were John McCarthy
(who invented Lisp and established Stanford AI Laboratory),
Marvin Minsky and Frank Rosenblatt (who invented perceptron algorithm)
and their work consisted of building theorem provers, natural language processing,
logic programming, etc.
<!---
### Neural Network

### Logic Programming
-->

Knowledge base systems
The next generation of AI research was on developing expert systems  where the focus was building a system that emulates the decision-making ability of a human expert. The expert system is an example of a broad class of system, commonly referred to as Knowledge base system. The Knowledge base system consists of two primary components:

Knowledge base Or fact base: A database that stores collection of facts or assertions (and may be even entities and relationships between entities).

Inference engine: applies set of logical rules on the facts available in the knowledge base to deduce new facts.

Here are some popular knowledge base systems:

In 1970, Shortliffe and others at Stanford developed an expert system for medical diagnosis called Mycin. Mycin would ask the physician a series of "yes or no" questions and would return list of (diagnosis (i.e. culprit bacteria), probability, reasoning behind the diagnosis, recommended drug treatment). To specify the "reasoning behind the diagnosis", Mycin would return list of questions/answers along with the set of rules that it used to come to the diagnosis.

Cyc developed by Douglas Lenat in 1984.

Sub-components of IBM Watson
Can you write Python code for it?

from IPython.display import YouTubeVideo
YouTubeVideo('_Xcmh1LQB9I')


I am working on the file "Chapter2.ipynb".
The first task is:
Because a list is ordered, the objects in the list can be accessed by stating at which place they are. To access an object in the list we use the square brackets again. In python (and most otehr programming languages) counts from $0$, which means that the first object in the list has index $0$, the second has index $1$ and so on. So to access an object in a list we simply type
Can you write Python code for it?

a[2] # Accessing the third element in the list. (This is acomment and is ignored by the interpreter.)

a[2][1] # We can access an objects in a list which is in a list

a[1] = 13.2 # We can change values of the objects in the list

a[0] + a[1] + a[2][1]


I am working on the file "Chapter2.ipynb".
The first task is:
Here, you saw the first occurrence of the print statement. It's functionality is much greater than prettifying string output as it can print text to the command or terminal window. One omportant functionality of the string is the format function. This function lets us create a string without knowing what it will contain beforehand.
Can you write Python code for it?

a = [1,2,3,4,5]

str = "The sum of {} is {}".format(a, sum(a))
str


I am working on the file "Chapter2.ipynb".
The first task is:
I mean that the command is written in the ipython command prompt (or in the ipython notebook if you prefer to use that). There are some lines above the command prompt. These are information on the current python and ipython version and tips on how to get help. But first, let us look at some of the basic operations, addition, subtraction, multiplication, division and exponentiation. In python, these would have the symbols +, -, *, / and **. If we would like to calculate
\begin{align}
\frac{3.6\cdot 5 + (3 - 2)^{3}}{2}
\end{align}
we would write
Can you write Python code for it?


I am working on the file "Chapter2.ipynb".
The first task is:
It uses curly brackets { and } as placeholders for the objects in the format part. There are many other things you can do with strings, to find out use the question mark, ?, in the interpreter after the variable you want more information about. Notice that this does not work in the regular python interpreter, you have to use ipython. You can also use the help function to get help about functions and variables. It works both in the regular interpreter and in ipython.
Can you write Python code for it?


I am working on the file "Chapter2.ipynb".
The first task is:
Now it seems as if we only should use floats and not use integers at all because of this property. But as we will se soon the integers will play a central role in loops.
Lists and tuples
Just as integers and floats are similar, so are lists and tuples. We will begin with lists. A list is an ordered collection of objects. The objects can be of any type, it can even contain itself! (But that is usually not very useful). A list is initiated with matching square brackets [ and ].
Can you write Python code for it?


I am working on the file "Chapter2.ipynb".
The first task is:
Often, this is not what you wanted. This leads us to the next object.
Floats
A float, or a floating point number, works very much like a real number in mathematics. The set of floats is closed under all the operations we have introduced just as the reals are. To declare a float we simply have to add a dot to the number we wish to have, like this
Can you write Python code for it?


I am working on the file "Chapter2.ipynb".
The first task is:
Python now knows that there is such a thing as $a$ which you can use to do further operations. For example, instead of writing
Can you write Python code for it?


I am working on the file "Chapter2.ipynb".
The first task is:
The lengt hof a list is not fixed in python and objects can be added and removed. To do this we will use append and del.
Can you write Python code for it?

a = [] # Creating an empty list
a

a.append('bleen')
a.append([2,4.1,'grue'])
a.append(4.3)
a

del a[-1] # We can also index from the end of the list. -1 indicates the last element
a


I am working on the file "Chapter2.ipynb".
The first task is:
These are the most basic operation and there are several more. We wont bother about them in this text though.
Variables
Python, as most programming languages relies on the fact that you can create something called a variable in it. This is similar to what in mathematics is called a variable and a constant. For example, we can define a variable with the name $a$ in python and let it have the value $5$ by typing
Can you write Python code for it?


I am working on the file "Chapter2.ipynb".
The first task is:
Tuples are initialized similarly as lists and they can contain most objects the list can contain. The main difference is that the tuple does not support item assignment. What this means is that when the tuple is created its objects can not change later. Tuples are initiated with matching parentheses ( and ).
Can you write Python code for it?


I am working on the file "Chapter2.ipynb".
The first task is:
We can write
Can you write Python code for it?


I am working on the file "Chapter2/2-Arrays.ipynb".
The first task is:
Now if we want to print the value of the first item in the recently created array slots, we get ValueError, which says we don't have value for referenced position. But if we assign values...
Can you write Python code for it?

slots[1] = 12
slots[3] = 44
slots[4] = 59
slots[3] = None

print slots[1]

print slots[3]

print slots[2]


I am working on the file "Chapter2/2-Arrays.ipynb".
The first task is:
Now our Array ADT is working like charm let's use it with somewhat better implementation. Let's count the number of occurrences of each letter in a text file using Array ADT:
Can you write Python code for it?

from array_class import Array1D

# Array theCounters created with size of 127 (ASCII characters)
theCounters = Array1D(127)
# theCounters elements initialized to 0
theCounters.clear(0)

# Open the text file for reading and extract each line from the file
# and iterate over each character in the line.
theFile = open('textfile.txt', 'r')
for line in theFile:
    for letter in line:
        code = ord(letter)
        theCounters[code] += 1
# Close the file
theFile.close()

# Print the results. The uppercase letters have ASCII values in the range 65..90
# the lowercase letters are in the range 97..122.
for i in range(26):
    print("%c - %4d         %c - %4d" % (chr(65+i), theCounters[65+i], chr(97+i), theCounters[97+i]))


I am working on the file "Chapter2/2-Arrays.ipynb".
The first task is:
To implement our array ADT we will use built-in module called ctypes which will give us an opportunity to implement hardware-supported array structure.
The ctypes module provides a tecnique for creating arrays that can store References to Python objects.
Can you write Python code for it?

import ctypes
ArrayType = ctypes.py_object * 5
slots = ArrayType()
slots[0]


I am working on the file "Chapter2/chptr2.3-R.ipynb".
The first task is:
2.3: Classical confidence intervals
CI for continuous data, Pg 18
Can you write Python code for it?


I am working on the file "Chapter2/chptr2.3-R.ipynb".
The first task is:
CI for proportions, Pg 18
Can you write Python code for it?

%%R
y <- 700
y

%%R
n <- 1000
n

%%R
estimate <- y/n
estimate

%%R
se <- sqrt(estimate*(1-estimate)/n)
se

%%R
int.95 <- estimate + qnorm(c(.025,.975))*se
int.95


I am working on the file "Chapter2/chptr2.3-R.ipynb".
The first task is:
CI using simulations, Pg 20
Can you write Python code for it?

%%R
n.men <- 500
n.men

%%R
p.hat.men <- 0.75
p.hat.men

%%R
se.men <- sqrt (p.hat.men*(1-p.hat.men)/n.men)
se.men

%%R
n.women <- 500
n.women

%%R
p.hat.women <- 0.65
p.hat.women

%%R
se.women <- sqrt(p.hat.women*(1-p.hat.women)/n.women)
se.women

%%R
n.sims <- 10000
n.sims

%%R
p.men <- rnorm(n.sims, p.hat.men, se.men)
p.men[1:10] # show first ten

%%R
p.women <- rnorm(n.sims, p.hat.women, se.women)
p.women[1:10] # show first ten

%%R
ratio <- p.men/p.women
ratio[1:10] # show first ten

%%R
int.95 <- quantile(ratio, c(.025,.975))
int.95


I am working on the file "Chapter2/chptr2.3-R.ipynb".
The first task is:
Plot Figure 2.3, Pg 19
Can you write Python code for it?

%%R
# Data is available in death.polls directory of ARM_Data
# Note: data seems to come from Gallup
# See: http://www.gallup.com/poll/1606/Death-Penalty.aspx
#
# Columns are
# 1- year
# 2- month
# 3- percentage support
# 4- percentage against
# 5- percentage no opinion
polls <- matrix(scan("../../ARM_Data/death.polls/polls.dat"),
                ncol=5, byrow=TRUE)
polls

%%R
# Note: this is the percentage support **among those that have an opinion** (pg 18)
#
# -- "No opinion" percentages are ignored
# -- !s a result, our plot below looks different from the Gallup plot
support <- polls[,3]/(polls[,3]+polls[,4])
support

%%R
year <-  polls[,1] + (polls[,2]-6)/12
year

%%R
# confidence intervals in plot assume sample size N=1000
# itervals are 68% confidence
par (mar=c(5,5,4,2)+.1)

plot(year, support*100, xlab="Year", ylim=c(min(100*support)-1, max(100*support)+1),
     ylab="Percentage support for the death penalty", cex=1.1, cex.main=1.2,
     cex.axis=1.1, cex.lab=1.1, pch=20)

for (i in 1:nrow(polls))
  lines (rep(year[i],2), 100*(support[i]+c(-1,1)*sqrt(support[i]*(1-support[i])/1000)))


I am working on the file "Chapter2/chptr2.3.ipynb".
The first task is:
CI for continuous data, Pg 18
Can you write Python code for it?

# import the t-distribution from scipy.stats
from scipy.stats import t

y = np.array([35,34,38,35,37])
y

n = len(y)
n

estimate = np.mean(y)
estimate


I am working on the file "Chapter2/chptr2.3.ipynb".
The first task is:
CI for discrete data, Pg 18
Can you write Python code for it?


I am working on the file "Chapter2/chptr2.3.ipynb".
The first task is:
CI for proportions, Pg 18
Can you write Python code for it?

from scipy.stats import norm

y = 700
y

n = 1000
n

estimate = y/n
estimate

se = np.sqrt(estimate*(1-estimate)/n)
se

int95 = estimate + norm.ppf([.025,0.975])*se
int95


I am working on the file "Chapter2/chptr2.3.ipynb".
The first task is:
See the note above about the difference different defaults for standard
deviation in Python and R.
Can you write Python code for it?

se = np.std(y, ddof=1)/np.sqrt(n)
se

int50 = estimate + t.ppf([0.25, 0.75], n-1)*se
int50

int95 = estimate + t.ppf([0.025, 0.975], n-1)*se
int95


I am working on the file "Chapter2/chptr2.3.ipynb".
The first task is:
Using knowledge of the file layout we can read in the file and pre-process into
appropriate rows/columns for passing into a pandas dataframe:
Can you write Python code for it?

# Data is available in death.polls directory of ARM_Data
data = []
temp = []
ncols = 5
with open("../../ARM_Data/death.polls/polls.dat") as f:
    for line in f.readlines():
        for d in line.strip().split(' '):
            temp.append(float(d))
        if (len(temp) == ncols):
            data.append(temp)
            temp = []

polls = pd.DataFrame(data, columns=[u'year', u'month', u'perc for',
                     u'perc against', u'perc no opinion'])
polls.head()

# --Note: this give the (percent) support for thise that have an opinion
# --The percentage with no opinion are ignored
# --This results in difference between our plot (below) and the Gallup plot (link above)
polls[u'support'] = polls[u'perc for']/(polls[u'perc for']+polls[u'perc against'])
polls.head()

polls[u'year_float'] = polls[u'year'] + (polls[u'month']-6)/12
polls.head()

# add error column -- symmetric so only add one column
# assumes sample size N=1000
# uses +/- 1 standard error, resulting in 68% confidence
polls[u'support_error'] = np.sqrt(polls[u'support']*(1-polls[u'support'])/1000)
polls.head()

fig, ax = plt.subplots(figsize=(8, 6))
plt.errorbar(polls[u'year_float'], 100*polls[u'support'],
             yerr=100*polls[u'support_error'], fmt='ko',
             ms=4, capsize=0)
plt.ylabel(u'Percentage support for the death penalty')
plt.xlabel(u'Year')

# you can adjust y-limits with command like below
# I will leave the default behavior
#plt.ylim(np.min(100*polls[u'support'])-2, np.max(100*polls[u'support']+2))


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Bi-implicação
Sejam p e q proposições. A bi-condicional ou bi-implicação de p e q é a proposição p$\leftrightarrow$q que é verdadeira
quando p e q têm o mesmo valor lógico.
A tabela de verdade de p$\leftrightarrow$q toma assim a forma:
$p$ | $q$ | $p$ $\leftrightarrow$ $q$
:------:|:-----:|:----------:
   V  |  V  |   V
   V  |  F  |   F
   F  |  V  |   F
   F  |  F  |   V
A proposição p$\leftrightarrow$q deve ler-se "p se e só se q"
(abreviado por "p sse q") ou "p é condição necessária e
suficiente para q".
Can you write Python code for it?

#
# Tabela da disjunção exclusiva
#
for p in [True,False]:
    for q in [True,False]:
        if p==q:
            print(p,'<->',q,'=', True)
        else:
            print(p,'<->',q,'=', False)


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Caso tenha de modificar a sequência durante o ciclo for (por exemplo para duplicar elementos seleccionados), é conveniente fazer primeiro uma cópia. A noção de slice torna isso possível:
Can you write Python code for it?

for w in words[:]:
    if len(w) > 6:
        words.insert(0, w)

words


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercício:
Apresente as tabelas de verdade  da implicação da bi-implicação e da proposição $P4:(p\rightarrow q)\vee h$. Por exemplo, tal que
  >>> TabelaP4()
  -----------------------------
    p  |  q  |  h  | (p->q)|h
  -----------------------------
  False|False|False|   True
  False|False| True|   True
  False| True|False|   True
  False| True| True|   True
   True|False|False|  False
   True|False| True|   True
   True| True|False|   True
   True| True| True|   True
Can you write Python code for it?

def TabelaP4():
    u''' TabelaP4()->

       tabela de (p->q)|h'''
    print('p'.center(5)+'|'+'q'.center(5)+'|'+'h'.center(5)+'| (p->q)|h')
    print('-'*27)
    for p in [False,True]:
        for q in [False,True]:
            for h in [False,True]:
                aval = imp(p,q) or h
                print(str(p).center(5)+'|'+str(q).center(5)+'|'+str(h).center(5)+'|'+str(aval).center(10))

TabelaP4()


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercício:
Defina a função
     cab(list)->
em que dado uma lista de strings ['p1','p2','p3',...,'pn'], imprima o cabeçalho duma tabela de verdade. Por exemplo, tal que
    >>> cab(['p1','p2','imp(p1,p2)'])
    -------------------------
     p1  | p2  |  imp(p1,p2)
    -------------------------
Can you write Python code for it?

def cab(lista):
    u''' cab(list)->

         Imprime cabeçalho de tabela'''
    print('-'*5*(len(lista)+1))
    for prop in lista[:-1]:
        print(prop.center(5)+'|', end='')
    print(lista[-1])  # imprime último elemento
    print('-'*5*(len(lista)+1))

cab(['p1','p2','imp(p1,p2)'])


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercício:
Defina a função
   Eval(string,list)->bool

que avalia a expressão proposicional, na sintaxe do Python, associando a cada variável usada <var> o valor lógico <bool>. A associação entre variáveis e valores lógicos deve ser descrita por pares (<var>,<bool>) na lista que serve de argumento.
Eval('(p1 and  not (p2 or p3))',[('p1',True),('p2',False),('p3',True)])} avalia '(True and  not (False or True))'.

Por exemplo, tal que
>>>  Eval('not(p1 and p2) or p1',[('p1',True),('p2',False)])
True
Can you write Python code for it?

def Eval(exp, atrib):
    u''' Eval(string,list)->bool

         Avalia a expressão proposicional, na sintaxe do Python,
         associando a cada variável usada <var> o valor lógico <bool>.
         A associação entre variáveis e valores lógicos deve ser descrita
         por pares (<var>,<bool>) na lista que serve de argumento.
             '''
    for var in atrib:
        exp = exp.replace(var[0],str(var[1]))
    return eval(exp)

Eval('not(p1 and p2) or p1',[('p1',True),('p2',False)])


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercício:
Relacione o valor lógico das proposições $p$, $q$, $r$ e
$(p\wedge (\neg q))\oplus (r\vee p)$.
Exercício:
Indique os valores (de verdade ou falsidade) das seguintes afirmações:
- $3\leq 7$ e 4 é um número inteiro ímpar.
- $3\leq 7$ ou 4 é um número inteiro ímpar.
- 5 é ímpar ou divisível por 4.
Implicação
Sejam p e q proposições. A implicação p$\rightarrow$q é
a proposição que é falsa quando p é verdadeira e q é falsa, nos
outros casos é verdadeira.
A tabela de verdade de p$\rightarrow$q toma assim a forma:
$p$ | $q$ | $p$ $\rightarrow$ $q$
:------:|:-----:|:----------:
   V  |  V  |   V
   V  |  F  |   F
   F  |  V  |   V
   F  |  F  |   V
Numa proposição do tipo p$\rightarrow$q a proposição p recebe o
nome de hipótese (antecedente ou premissa) e a q chama-se
tese (conclusão ou consequente). A proposição p$\rightarrow$q também é muitas vezes designada por declaração
condicional. Estas designações são compatíveis com o uso da implicação em linguagem corrente, devemos no entanto notar que a tabela entra em conflito com a interpretação que fazemos da implicação: neste caso não se dirá "p implica q" quando se sabe à priori que p é falsa. Na interpretação que apresentamos para a implicação ela é verdade sempre que "p" é falsa independentemente do valor lógico de "q". Esta situação pode ilustrar-se com a implicação "se 1+1=1 então 2=3" que é verdadeira, uma vez que o antecedente é falso.
Can you write Python code for it?

#
# Tabela da implicação
#

for p in [True,False]:
    for q in [True,False]:
        if p and not q:
            print(p,'-->',q,'=',False)
        else:
            print(p,'-->',q,'=',True)


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercício:
Represente em representação binário os números de $2^n-1$ até zero. Exemplo:
>>> binlist(3)
111
110
101
100
011
010
001
000
Can you write Python code for it?

def binlist(nvar):
    u''' binlist(int)->

         lista em representação binária os números de 2**n-1 até 0
             '''
    for n in range(2**nvar-1,-1,-1):
        print(bin(n)[2:].rjust(nvar,'0'))

binlist(3)


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercício:
Usando as funções anteriores, defina uma função
     tabela(string, list)->
que imprima a tabela de verdade da proposição $q$, descrita pela string, assumindo que as suas variáveis estão na lista $[p1,p2,...,pn]$. (USANDO: a linguagem proposicional de símbolos 0,1,\&,$|$ e $\sim$, mais as funções imp(bool,bool)->bool e biimp(bool,bool)->bool))
    Por exemplo, tal que
  >>> tabela('imp(u,q)|w',['u','q','w'])
    -------------------------
      u  |  q  |  w  |imp(u,q)|w
    -------------------------
     True| True| True|True
     True| True|False|True
     True|False| True|True
     True|False|False|False
    False| True| True|True
    False| True|False|True
    False|False| True|True
    False|False|False|True
Can you write Python code for it?

def tabela(exp,var):
    u''' tabela(str,list)->

         Imprime a tabela de verdade da proposição descrita pela string,
         assumindo que as suas variáveis estão na lista.
         USANDO: a linguagem proposicional de símbolos 0,1,\&,$|$ e $\sim$,
                 mais as funções imp(bool,bool)->bool e biimp(bool,bool)->bool)
             '''
    cab(var+[exp])
    nvar = len(var)
    for n in range(2**nvar-1,-1,-1):
        l=bin(n)[2:].rjust(nvar,'0')
        cont=0
        lista = []
        vlog = []
        for v in var:
            lista.append((v,bool(int(l[cont]))))
            vlog.append(bool(int(l[cont])))
            cont = cont + 1
        linha(vlog+ [Eval(trad(exp),lista)])

tabela('imp(u,q)|w',['u','q','w'])


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercício:
Usando as funções anteriores, defina uma função
tautologia(string, list)->bool

que verifica se a proposição $q$, descrita pela string, é uma tautologia e assumindo que as suas variáveis estão descritas na lista $[p1,p2,...p_n]$. (USANDO: a linguagem proposicional de símbolos 0,1,\&,$|$ e $\sim$, mais as funções imp(bool,bool)->bool e biimp(bool,bool)->bool)
  >>>  tautologia('biimp(~q | w, imp(q,w))',['q','w'])
  False
Can you write Python code for it?

def tautologia(exp,var):
    u''' tautologia(str,list)->bool

         Verifica se a proposição descrita pela string é uma tautologia,
         assumindo que as suas variáveis estão descritas na lista.
         USANDO: a linguagem proposicional de símbolos 0,1,\&,$|$ e $\sim$,
         mais as funções imp(bool,bool)->bool e biimp(bool,bool)->bool
             '''
    sai = True
    nvar = len(var)
    for n in range(2**nvar-1,-1,-1):
        l=str(bin(n))[2:].rjust(nvar,'0')
        cont=0
        lista = []
        for v in var:
            lista.append((v,bool(int(l[cont]))))
            cont = cont + 1
        sai = sai and bool(Eval(exp,lista))
    return sai

tautologia('biimp(~q | w, imp(q,w))',['q','w'])


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Exercícios de python
Exercício:
Implemente os operadores de implicação e bi-implicação, através de funções
imp(bool,bool)->bool e biimp(bool,bool)->bool.
Can you write Python code for it?

def imp(p,q):
    u''' imp(bool,bool)->bool
         Operador de implicação '''
    return not p or q

def biimp(p,q):
    u''' biimp(bool,bool)->bool
         Operador de bi-implicação'''
    return imp(p,q) and imp(q,p)

imp(False,True)

biimp(False,True)


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Facilmente podemos mostrar que as proposições p$\leftrightarrow$q
e  $(p\rightarrow q)\wedge(q\rightarrow p)$ têm os mesmos valores
lógicos, ou seja a proposição $(p\leftrightarrow  q)\leftrightarrow
((p\rightarrow q)\wedge(q\rightarrow p))$ é sempre verdadeira.
(p | $\leftrightarrow$ | q) | $\leftrightarrow$ | ((p | $\rightarrow$ | q) | $\wedge$ | (q | $\rightarrow$  | p))
:------:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:|:----:
  V   |  V | V  |  V |  V |  V |  V |  V |  V |  V |  V
  V   |  F | F  |  V |  V |  F |  F |  F |  F |  V |  V
  F   |  F | V  |  V |  F |  V |  V |  F |  V |  F |  F
  F   |  V | F  |  V |  F |  V |  F |  V |  F |  V |  F
------|----|----|----|----|----|----|----|----|----|----
1  | 2 | 1 | 4 | 1 | 2 | 1 | 3 | 1 | 2 | 1
Exercício:
Suponhamos que p,q,r representam as seguintes sentenças:

$p:$"7 é um número inteiro par"
$q:3+1=4$
$r:$"24 é divisível por 8"

Escreva em linguagem simbólica as proposições

$3+1\neq 4$ e 24 é divisível por 8

não é verdade que 7 seja ímpar ou 3+1=4

se 3+1=4 então 24 não é divisível por 8

Escreva por palavras as sentenças

$p\vee(\neg q)$

$\neg(p\wedge q)$

$(\neg r)\vee (\neg q)$

Exercício:
Construir as tabelas de verdade das seguintes proposições:
1. $((p\rightarrow q)\wedge p)\rightarrow q$
1. $p\leftrightarrow(q\rightarrow r)$
1. $(p\wedge(\neg p))\rightarrow q$
1. $((p\vee r)\wedge(q\vee r))\wedge((\neg p)\vee (\neg r))$
1. $(p\wedge(q\vee r))\wedge (q\wedge (p\vee r))$
Exercício:
Quantas linhas tem a tabela de verdade de uma proposição com $n$ variáveis proposicionais?
Ordem de precedência das conectivas lógicas
Até aqui, temos usado parêntesis para definir a ordem de
aplicação dos operadores lógicos numa proposição composta. Por forma
a reduzir o número de parêntesis adoptamos a seguinte convenção: Sempre que numa expressão estiverem presentes várias operações lógicas, convenciona-se, na ausência de parêntesis, que as operações se efectuem na ordem seguinte:
1. a negação;
1. a conjunção e a...
Can you write Python code for it?

x = int(input("Escreva um inteiro: "))

if x < 0:
    x = 0
    print('É negativo... vou transforma-lo em zero!')
elif x == 0:
    print('É zero')
elif x == 1:
    print('É a unidade.')
else:
    print('É num número grande!')


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Já vimos que podem existir um ou mais blocos elif, e o bloco else é opcional. O comando elif é uma abreviação para ``else if'', sendo útil para reduzir a quantidade de indentações. Uma sequência if ... elif ... elif ... é o substituto para os comandos switch ou case disponíveis noutras linguagens de programação.
Python: de volta  ao comando for
Como vimos no Python o comando for permite iterar sobre objectos de qualquer sequência (uma lista ou uma string) ou um conjunto, nas sequências o ciclo for segue a ordem pela qual os objectos aparecem na sequência. Por examplo:
Can you write Python code for it?

# Medindo strings
words = ['Platão', 'Sócrates', 'Eu']
for w in words:
    print(w, len(w))


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Na maioria dos casos, é conveniente usar a função enumerate().
Python:Comando break e continue, e cláusulas else nos ciclos
O comando break, permite encurtar os ciclos for ou while.
Os ciclos podem ter uma cláusula else; que é executado após ter percorrido todo o domínio do ciclo for ou quando a condição dum ciclo  while se torna falsa, mas nunca quando o ciclo é interrompido com um comando break. Exemplificamos isto no ciclo seguinte, que tem por objectivo determinar números primos (recorde quando é um número natural primo):
Can you write Python code for it?

#
# O crivo de Eratóstenes
#
for n in range(2, 10):
    for m in range(2, n):
        if n % m == 0:
            print(n, '=', m, '*', n//m, "=>",n,'não é primo')
            break
        else:
            print(n,' é um primo')


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
O ponto final nunca é parte da lista gerada; range(10) gera uma sequência de 10 valores, os índices de uma lista com 10 objectos. É possível fazer o domínio ter inicio noutro número, ou indicar um incremento diferente (mesmo negativo; este incremento é usualmente designado de 'passo'):
Can you write Python code for it?

for i in range(5, 10): print(i,' ',end='')

for i in range(0, 10, 3): print(i,' ',end='')

for i in range(-10, -100, -30): print(i,' ',end='')


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
O que faz a operador binário %?
O que faz a operador binário //? Onde está a diferênça entre / e //
O comando continue pára a iteração corrente, saltando para a iteração seguinte do loop:
Can you write Python code for it?

for num in range(2, 10):
    if num % 2 == 0:
        print("É par o número ", num)
        continue
    print("O número ", num, "é ímpar")


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Para iterar nos índices de uma sequência, pode combinar range() com a função len() como por exemplo:
Can you write Python code for it?

a = ['Euler', 'Decarte', 'Pascal', 'Newton', 'Eu']
for i in range(len(a)):
    print( i, a[i])


I am working on the file "Chapter2_Calculo_Proposicional/Chapter2_Calculo_Proposicional.ipynb".
The first task is:
Python: A função range()
Quando temos de iterar numa sequência de números, a função built-in  range() trata do assunto. Permitindo gerar progressões aritméticas
Can you write Python code for it?

L=range(10)

for i in L: print(i,' ',end='')


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
2. Draw $\lambda_1$ and $\lambda_2$ from an $\text{Exp}(\alpha)$ distribution:
Can you write Python code for it?

alpha = 1. / 20.
lambda_1, lambda_2 = pm.rexponential(alpha, 2)
print(lambda_1, lambda_2)


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
3.  For days before $\tau$, represent the user's received SMS count by sampling from $\text{Poi}(\lambda_1)$, and sample from  $\text{Poi}(\lambda_2)$ for days after $\tau$. For example:
Can you write Python code for it?

data = np.r_[pm.rpoisson(lambda_1, tau), pm.rpoisson(lambda_2, 80 - tau)]


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
4. Plot the artificial dataset:
Can you write Python code for it?

plt.bar(np.arange(80), data, color="#348ABD")
plt.bar(tau - 1, data[tau - 1], color="r", label="user behaviour changed")
plt.xlabel("Time (days)")
plt.ylabel("count of text-msgs received")
plt.title("Artificial dataset")
plt.xlim(0, 80)
plt.legend();


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
A Normal random variable can be take on any real number, but the variable is very likely to be relatively close to $\mu$. In fact, the expected value of a Normal is equal to its $\mu$ parameter:
$$ E[ X | \mu, \tau] = \mu$$
and its variance is equal to the inverse of $\tau$:
$$Var( X | \mu, \tau ) = \frac{1}{\tau}$$
Below we continue our modeling of the Challenger space craft:
Can you write Python code for it?

import pymc as pm

temperature = challenger_data[:, 0]
D = challenger_data[:, 1]  # defect or not?

# notice the`value` here. We explain why below.
beta = pm.Normal("beta", 0, 0.001, value=0)
alpha = pm.Normal("alpha", 0, 0.001, value=0)

@pm.deterministic
def p(t=temperature, alpha=alpha, beta=beta):
    return 1.0 / (1. + np.exp(beta * t + alpha))


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Above we also plotted two possible realizations of what the actual underlying system might be. Both are equally likely as any other draw. The blue line is what occurs when we average all the 20000 possible dotted lines together.
An interesting question to ask is for what temperatures are we most uncertain about the defect-probability? Below we plot the expected value line and the associated 95% intervals for each temperature.
Can you write Python code for it?

from scipy.stats.mstats import mquantiles

# vectorized bottom and top 2.5% quantiles for "confidence interval"
qs = mquantiles(p_t, [0.025, 0.975], axis=0)
plt.fill_between(t[:, 0], *qs, alpha=0.7,
                 color="#7A68A6")

plt.plot(t[:, 0], qs[0], label="95% CI", color="#7A68A6", alpha=0.7)

plt.plot(t, mean_prob_t, lw=1, ls="--", color="k",
         label="average posterior \nprobability of defect")

plt.xlim(t.min(), t.max())
plt.ylim(-0.02, 1.02)
plt.legend(loc="lower left")
plt.scatter(temperature, D, color="k", s=50, alpha=0.5)
plt.xlabel("temp, $t$")

plt.ylabel("probability estimate")
plt.title("Posterior probability estimates given temp. $t$");


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Adding a constant term $\alpha$ amounts to shifting the curve left or right (hence why it is called a bias).
Let's start modeling this in PyMC. The $\beta, \alpha$ parameters have no reason to be positive, bounded or relatively large, so they are best modeled by a Normal random variable, introduced next.
Normal distributions
A Normal random variable, denoted $X \sim N(\mu, 1/\tau)$, has a distribution with two parameters: the mean, $\mu$, and the precision, $\tau$. Those familiar with the Normal distribution already have probably seen $\sigma^2$ instead of $\tau^{-1}$. They are in fact reciprocals of each other. The change was motivated by simpler mathematical analysis and is an artifact of older Bayesian methods. Just remember: the smaller $\tau$, the larger the spread of the distribution (i.e. we are more uncertain); the larger $\tau$, the tighter the distribution (i.e. we are more certain). Regardless, $\tau$ is always positive.
The probability density function of a $N( \mu, 1/\tau)$ random variable is:
$$ f(x | \mu, \tau) = \sqrt{\frac{\tau}{2\pi}} \exp\left( -\frac{\tau}{2} (x-\mu)^2 \right) $$
We plot some different density functions below.
Can you write Python code for it?

import scipy.stats as stats

nor = stats.norm
x = np.linspace(-8, 7, 150)
mu = (-2, 0, 3)
tau = (.7, 1, 2.8)
colors = ["#348ABD", "#A60628", "#7A68A6"]
parameters = zip(mu, tau, colors)

for _mu, _tau, _color in parameters:
    plt.plot(x, nor.pdf(x, _mu, scale=1. / np.sqrt(_tau)),
             label="$\mu = %d,\;\\tau = %.1f$" % (_mu, _tau), color=_color)
    plt.fill_between(x, nor.pdf(x, _mu, scale=1. / np.sqrt(_tau)), color=_color,
                     alpha=.33)

plt.legend(loc="upper right")
plt.xlabel("$x$")
plt.ylabel("density function at $x$")
plt.title("Probability distribution of three different Normal random \
variables");


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Again, thinking of our data-generation model, we assign Bernoulli random variables to the 100 students: 1 implies they cheated and 0 implies they did not.
Can you write Python code for it?

true_answers = pm.Bernoulli("truths", p, size=N)


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
All samples of $\beta$ are greater than 0. If instead the posterior was centered around 0, we may suspect that $\beta = 0$, implying that temperature has no effect on the probability of defect.
Similarly, all $\alpha$ posterior values are negative and far away from 0, implying that it is correct to believe that $\alpha$ is significantly less than 0.
Regarding the spread of the data, we are very uncertain about what the true parameters might be (though considering the low sample size and the large overlap of defects-to-nondefects this behaviour is perhaps expected).
Next, let's look at the expected probability for a specific value of the temperature. That is, we average over all samples from the posterior to get a likely value for $p(t_i)$.
Can you write Python code for it?

t = np.linspace(temperature.min() - 5, temperature.max() + 5, 50)[:, None]
p_t = logistic(t.T, beta_samples, alpha_samples)

mean_prob_t = p_t.mean(axis=0)

figsize(12.5, 4)

plt.plot(t, mean_prob_t, lw=3, label="average posterior \nprobability \
of defect")
plt.plot(t, p_t[0, :], ls="--", label="realization from posterior")
plt.plot(t, p_t[-2, :], ls="--", label="realization from posterior")
plt.scatter(temperature, D, color="k", s=50, alpha=0.5)
plt.title("Posterior expected value of probability of defect; \
plus realizations")
plt.legend(loc="lower left")
plt.ylim(-0.1, 1.1)
plt.xlim(t.min(), t.max())
plt.ylabel("probability")
plt.xlabel("temperature");


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Although not everyone flips a second time, we can still model the possible realization of second coin-flips:
Can you write Python code for it?

second_coin_flips = pm.Bernoulli("second_flips", 0.5, size=N)


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Below we add all the variables of interest to a Model container and run our black-box algorithm over the model.
Can you write Python code for it?

model = pm.Model([yes_responses, p_skewed, p])

# To Be Explained in Chapter 3!
mcmc = pm.MCMC(model)
mcmc.sample(25000, 2500)

figsize(12.5, 3)
p_trace = mcmc.trace("freq_cheating")[:]
plt.hist(p_trace, histtype="stepfilled", density=True, alpha=0.85, bins=30,
         label="posterior distribution", color="#348ABD")
plt.vlines([.05, .35], [0, 0], [5, 5], alpha=0.2)
plt.xlim(0, 1)
plt.legend();


model = pm.Model([yes_responses, p_skewed, p])

# To Be Explained in Chapter 3!
mcmc = pm.MCMC(model)
mcmc.sample(25000, 2500)

figsize(12.5, 3)
p_trace = mcmc.trace("freq_cheating")[:]
plt.hist(p_trace, histtype="stepfilled", normed=True, alpha=0.85, bins=30,
         label="posterior distribution", color="#348ABD")
plt.vlines([.05, .35], [0, 0], [5, 5], alpha=0.2)
plt.xlim(0, 1)
plt.legend();


model = pm.Model([p, true_answers, first_coin_flips,
                  second_coin_flips, observed_proportion, observations])

# To be explained in Chapter 3!
mcmc = pm.MCMC(model)
mcmc.sample(40000, 15000)

figsize(12.5, 3)
p_trace = mcmc.trace("freq_cheating")[:]
plt.hist(p_trace, histtype="stepfilled", density=True, alpha=0.85, bins=30,
         label="posterior distribution", color="#348ABD")
plt.vlines([.05, .35], [0, 0], [5, 5], alpha=0.3)
plt.xlim(0, 1)
plt.legend();


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Below we plot the posterior distributions for the three unknowns:
Can you write Python code for it?

p_A_samples = mcmc.trace("p_A")[:]
p_B_samples = mcmc.trace("p_B")[:]
delta_samples = mcmc.trace("delta")[:]

figsize(12.5, 10)

# histogram of posteriors

ax = plt.subplot(311)

plt.xlim(0, .1)
plt.hist(p_A_samples, histtype='stepfilled', bins=25, alpha=0.85,
         label="posterior of $p_A$", color="#A60628", density=True)
plt.vlines(true_p_A, 0, 80, linestyle="--", label="true $p_A$ (unknown)")
plt.legend(loc="upper right")
plt.title("Posterior distributions of $p_A$, $p_B$, and delta unknowns")

ax = plt.subplot(312)

plt.xlim(0, .1)
plt.hist(p_B_samples, histtype='stepfilled', bins=25, alpha=0.85,
         label="posterior of $p_B$", color="#467821", density=True)
plt.vlines(true_p_B, 0, 80, linestyle="--", label="true $p_B$ (unknown)")
plt.legend(loc="upper right")

ax = plt.subplot(313)
plt.hist(delta_samples, histtype='stepfilled', bins=30, alpha=0.85,
         label="posterior of delta", color="#7A68A6", density=True)
plt.vlines(true_p_A - true_p_B, 0, 60, linestyle="--",
           label="true delta (unknown)")
plt.vlines(0, 0, 60, color="black", alpha=0.2)
plt.legend(loc="upper right");


p_A_samples = mcmc.trace("p_A")[:]
p_B_samples = mcmc.trace("p_B")[:]
delta_samples = mcmc.trace("delta")[:]

figsize(12.5, 10)

# histogram of posteriors

ax = plt.subplot(311)

plt.xlim(0, .1)
plt.hist(p_A_samples, histtype='stepfilled', bins=25, alpha=0.85,
         label="posterior of $p_A$", color="#A60628", normed=True)
plt.vlines(true_p_A, 0, 80, linestyle="--", label="true $p_A$ (unknown)")
plt.legend(loc="upper right")
plt.title("Posterior distributions of $p_A$, $p_B$, and delta unknowns")

ax = plt.subplot(312)

plt.xlim(0, .1)
plt.hist(p_B_samples, histtype='stepfilled', bins=25, alpha=0.85,
         label="posterior of $p_B$", color="#467821", normed=True)
plt.vlines(true_p_B, 0, 80, linestyle="--", label="true $p_B$ (unknown)")
plt.legend(loc="upper right")

ax = plt.subplot(313)
plt.hist(delta_samples, histtype='stepfilled', bins=30, alpha=0.85,
         label="posterior of delta", color="#7A68A6", normed=True)
plt.vlines(true_p_A - true_p_B, 0, 60, linestyle="--",
           label="true delta (unknown)")
plt.vlines(0, 0, 60, color="black", alpha=0.2)
plt.legend(loc="upper right");


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
But something is missing. In the plot of the logistic function, the probability changes only near zero, but in our data above the probability changes around 65 to 70. We need to add a bias term to our logistic function:
$$p(t) = \frac{1}{ 1 + e^{ \;\beta t + \alpha } } $$
Some plots are below, with differing $\alpha$.
Can you write Python code for it?

def logistic(x, beta, alpha=0):
    return 1.0 / (1.0 + np.exp(np.dot(beta, x) + alpha))

x = np.linspace(-4, 4, 100)

plt.plot(x, logistic(x, 1), label=r"$\beta = 1$", ls="--", lw=1)
plt.plot(x, logistic(x, 3), label=r"$\beta = 3$", ls="--", lw=1)
plt.plot(x, logistic(x, -5), label=r"$\beta = -5$", ls="--", lw=1)

plt.plot(x, logistic(x, 1, 1), label=r"$\beta = 1, \alpha = 1$",
         color="#348ABD")
plt.plot(x, logistic(x, 3, -2), label=r"$\beta = 3, \alpha = -2$",
         color="#A60628")
plt.plot(x, logistic(x, -5, 7), label=r"$\beta = -5, \alpha = 7$",
         color="#7A68A6")

plt.title("Logistic functon with bias, plotted for several value of $\\alpha$ bias parameter", fontsize=14)
plt.legend(loc="lower left");


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Finally...
We wrap all the created variables into a pm.Model class. With this Model class, we can analyze the variables as a single unit. This is an optional step, as the fitting algorithms can be sent an array of the variables rather than a Model class. I may or may not use this class in future examples ;)
Can you write Python code for it?

model = pm.Model([obs, lambda_, lambda_1, lambda_2, tau])


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Had we had stronger beliefs, we could have expressed them in the prior above.
For this example, consider $p_A = 0.05$, and $N = 1500$ users shown site A, and we will simulate whether the user made a purchase or not. To simulate this from $N$ trials, we will use a Bernoulli distribution: if  $X\ \sim \text{Ber}(p)$, then $X$ is 1 with probability $p$ and 0 with probability $1 - p$. Of course, in practice we do not know $p_A$, but we will use it here to simulate the data.
Can you write Python code for it?

# set constants
p_true = 0.05  # remember, this is unknown.
N = 1500

# sample N Bernoulli random variables from Ber(0.05).
# each random variable has a 0.05 chance of being a 1.
# this is the data-generation step
occurrences = pm.rbernoulli(p_true, N)

print(occurrences)  # Remember: Python treats True == 1, and False == 0
print(occurrences.sum())


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
I could have typed p_skewed  = 0.5*p + 0.25 instead for a one-liner, as the elementary operations of addition and scalar multiplication will implicitly create a deterministic variable, but I wanted to make the deterministic boilerplate explicit for clarity's sake.
If we know the probability of respondents saying "Yes", which is p_skewed, and we have $N=100$ students, the number of "Yes" responses is a binomial random variable with parameters N and p_skewed.
This is where we include our observed 35 "Yes" responses. In the declaration of the pm.Binomial, we include value = 35 and observed = True.
Can you write Python code for it?

yes_responses = pm.Binomial("number_cheaters", 100, p_skewed,
                            value=35, observed=True)


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
If this probability is too high for comfortable decision-making, we can perform more trials on site B (as site B has less samples to begin with, each additional data point for site B contributes more inferential "power" than each additional data point for site A).
Try playing with the parameters true_p_A, true_p_B, N_A, and N_B, to see what the posterior of $\text{delta}$ looks like. Notice in all this, the difference in sample sizes between site A and site B was never mentioned: it naturally fits into Bayesian analysis.
I hope the readers feel this style of A/B testing is more natural than hypothesis testing, which has probably confused more than helped practitioners. Later in this book, we will see two extensions of this model: the first to help dynamically adjust for bad sites, and the second will improve the speed of this computation by reducing the analysis to a single equation.
An algorithm for human deceit
Social data has an additional layer of interest as people are not always honest with responses, which adds a further complication into inference. For example, simply asking individuals "Have you ever cheated on a test?" will surely contain some rate of dishonesty. What you can say for certain is that the true rate is less than your observed rate (assuming individuals lie only about not cheating; I cannot imagine one who would admit "Yes" to cheating when in fact they hadn't cheated).
To present an elegant solution to circumventing this dishonesty problem, and to demonstrate Bayesian modeling, we first need to introduce the binomial distribution.
The Binomial Distribution
The binomial distribution is one of the most popular distributions, mostly because of its simplicity and usefulness. Unlike the other distributions we have encountered thus far in the book, the binomial distribution has 2 parameters: $N$, a positive integer representing $N$ trials or number of instances of potential events, and $p$, the probability of an event occurring in a single trial. Like the Poisson distribution, it is a...
Can you write Python code for it?

figsize(12.5, 4)

import scipy.stats as stats
binomial = stats.binom

parameters = [(10, .4), (10, .9)]
colors = ["#348ABD", "#A60628"]

for i in range(2):
    N, p = parameters[i]
    _x = np.arange(N + 1)
    plt.bar(_x - 0.5, binomial.pmf(_x, N, p), color=colors[i],
            edgecolor=colors[i],
            alpha=0.6,
            label="$N$: %d, $p$: %.1f" % (N, p),
            linewidth=3)

plt.legend(loc="upper left")
plt.xlim(0, 10.5)
plt.xlabel("$k$")
plt.ylabel("$P(X = k)$")
plt.title("Probability mass distributions of binomial random variables");


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
If we carry out the algorithm, the next step that occurs is the first coin-flip each student makes. This can be modeled again by sampling 100 Bernoulli random variables with $p=1/2$: denote a 1 as a Heads and 0 a Tails.
Can you write Python code for it?

first_coin_flips = pm.Bernoulli("first_flips", 0.5, size=N)
print(first_coin_flips.value)


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
In the random model, we can see that as the probability increases there is no clustering of defects to the right-hand side. Similarly for the constant model.
The perfect model, the probability line is not well shown, as it is stuck to the bottom and top of the figure. Of course the perfect model is only for demonstration, and we cannot infer any scientific inference from it.
Exercises
1. Try putting in extreme values for our observations in the cheating example. What happens if we observe 25 affirmative responses? 10? 50?
2. Try plotting $\alpha$ samples versus $\beta$ samples.  Why might the resulting plot look like this?
Can you write Python code for it?

# type your code here.
figsize(12.5, 4)

plt.scatter(alpha_samples, beta_samples, alpha=0.1)
plt.title("Why does the plot look like this?")
plt.xlabel(r"$\alpha$")
plt.ylabel(r"$\beta$");


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
Is our model appropriate?
The skeptical reader will say "You deliberately chose the logistic function for $p(t)$ and the specific priors. Perhaps other functions or priors will give different results. How do I know I have chosen a good model?" This is absolutely true. To consider an extreme situation, what if I had chosen the function $p(t) = 1,\; \forall t$, which guarantees a defect always occurring: I would have again predicted disaster on January 28th. Yet this is clearly a poorly chosen model. On the other hand, if I did choose the logistic function for $p(t)$, but specified all my priors to be very tight around 0, likely we would have very different posterior distributions. How do we know our model is an expression of the data? This encourages us to measure the model's goodness of fit.
We can think: how can we test whether our model is a bad fit? An idea is to compare observed data (which if we recall is a fixed stochastic variable) with an artificial dataset which we can simulate. The rationale is that if the simulated dataset does not appear similar, statistically, to the observed dataset, then likely our model is not accurately represented the observed data.
Previously in this Chapter, we simulated artificial datasets for the SMS example. To do this, we sampled values from the priors. We saw how varied the resulting datasets looked like, and rarely did they mimic our observed dataset. In the current example,  we should sample from the posterior distributions to create very plausible datasets. Luckily, our Bayesian framework makes this very easy. We only need to create a new Stochastic variable, that is exactly the same as our variable that stored the observations, but minus the observations themselves. If you recall, our Stochastic variable that stored our observed data was:
observed = pm.Bernoulli( "bernoulli_obs", p, value=D, observed=True)

Hence we create:
simulated_data = pm.Bernoulli("simulation_data", p)

Let's simulate 10 000:
Can you write Python code for it?

simulated = pm.Bernoulli("bernoulli_sim", p)
N = 10000

mcmc = pm.MCMC([simulated, alpha, beta, observed])
mcmc.sample(N)

figsize(12.5, 5)

simulations = mcmc.trace("bernoulli_sim")[:]
print(simulations.shape)

plt.title("Simulated dataset using posterior parameters")
figsize(12.5, 6)
for i in range(4):
    ax = plt.subplot(4, 1, i + 1)
    plt.scatter(temperature, simulations[1000 * i, :], color="k",
                s=50, alpha=0.6)


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
It is okay that our fictional dataset does not look like our observed dataset: the probability is incredibly small it indeed would. PyMC's engine is designed to find good parameters, $\lambda_i, \tau$, that maximize this probability.
The ability to generate artificial datasets is an interesting side effect of our modeling, and we will see that this ability is a very important method of Bayesian inference. We produce a few more datasets below:
Can you write Python code for it?

def plot_artificial_sms_dataset():
    tau = pm.rdiscrete_uniform(0, 80)
    alpha = 1. / 20.
    lambda_1, lambda_2 = pm.rexponential(alpha, 2)
    data = np.r_[pm.rpoisson(lambda_1, tau), pm.rpoisson(lambda_2, 80 - tau)]
    plt.bar(np.arange(80), data, color="#348ABD")
    plt.bar(tau - 1, data[tau - 1], color="r", label="user behaviour changed")
    plt.xlim(0, 80)

figsize(12.5, 5)
plt.suptitle("More examples of artificial datasets", fontsize=14)
for i in range(1, 5):
    plt.subplot(4, 1, i)
    plot_artificial_sms_dataset()


I am working on the file "Chapter2_MorePyMC/Ch2_MorePyMC_PyMC2.ipynb".
The first task is:
It looks clear that the probability of damage incidents occurring increases as the outside temperature decreases. We are interested in modeling the probability here because it does not look like there is a strict cutoff point between temperature and a damage incident occurring. The best we can do is ask "At temperature $t$, what is the probability of a damage incident?". The goal of this example is to answer that question.
We need a function of temperature, call it $p(t)$, that is bounded between 0 and 1 (so as to model a probability) and changes from 1 to 0 as we increase temperature. There are actually many such functions, but the most popular choice is the logistic function.
$$p(t) = \frac{1}{ 1 + e^{ \;\beta t } } $$
In this model, $\beta$ is the variable we are uncertain about. Below is the function plotted for $\beta = 1, 3, -5$.
Can you write Python code for it?

figsize(12, 3)

def logistic(x, beta):
    return 1.0 / (1.0 + np.exp(beta * x))

x = np.linspace(-4, 4, 100)
plt.plot(x, logistic(x, 1), label=r"$\beta = 1$")
plt.plot(x, logistic(x, 3), label=r"$\beta = 3$")
plt.plot(x, logistic(x, -5), label=r"$\beta = -5$")
plt.title("Logistic functon plotted for several value of $\\beta$ parameter", fontsize=14)
plt.legend();