I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Descriptive Analysis
Q1. How many mutually exclusive ADHD and Bipolar samples do we have?
Can you write Python code for it?

c1, c2 = 0, 0
adhd_id, bipolar_id = list(), list()

for i, a, b in df_disorders[['Patient_ID', 'ADHD', 'Bipolar']].values:
    if a == 1 and b == 0:
        c1 += 1
        adhd_id.append(i)
    elif a == 0 and b == 1:
        c2 += 1
        bipolar_id.append(i)

print 'Number of ADHD patients (without Bipolar) is', c1
print 'Number of Bipolar patients (without ADHD) is', c2

# Extract Learning Disablity Screening Questionnair data
df_questionnaire.drop(['Patient_ID', 'LDS_Respondent'], axis=1, inplace=True)
lds = list()
for col in df_questionnaire.columns:
    if 'LDS' in col:
        lds.append(col)
df_lds = df_questionnaire[lds]

# Separate baseline from concentration rCBF values
df_base_concen.drop(['Baseline_header_id', 'Concentration_header_id'], axis=1, inplace=True)
base, concen = list(), list()
for col in df_base_concen.columns:
    if 'Baseline' in col:
        base.append(col)
    elif 'Concentration' in col:
        concen.append(col)
df_base = df_base_concen[base]
df_concen = df_base_concen[concen]

# Get basic personal info and rCBF values
df_patient = df_patient[['Patient_ID', 'Age', 'Gender_id', 'race_id', 'location_id']]
df = pd.concat([df_patient, df_lds, df_base, df_concen], axis=1)

# Original positive and negative features
df_adhd = df.loc[df['Patient_ID'].isin(adhd_id)].drop(['Patient_ID'], axis=1)
df_bipolar = df.loc[df['Patient_ID'].isin(bipolar_id)].drop(['Patient_ID'], axis=1)
df_adhd.shape, df_bipolar.shape


I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Exploratory Analysis
Principal Component Analysis
Can you write Python code for it?

%matplotlib inline
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

# Plot explained variance ratio
def plot(ex_var_ratio):
    plt.plot(ex_var_ratio)
    plt.ylabel('Explained Variance Ratio')
    plt.xlabel('Number of Principal Components')

def pca(X, n):
    pca = PCA(n_components=n)
    pca_X = pca.fit_transform(X)

    print '\nExplained Variance Ratios:'
    print pca.explained_variance_ratio_
    print '\nSum of Explained Variance Ratios:',
    print np.sum(pca.explained_variance_ratio_)

    return pca_X, pca.explained_variance_ratio_

from sklearn.decomposition import SparsePCA

# Compute explained variance ratio of transformed data
def compute_explained_variance_ratio(transformed_data):
    explained_variance = np.var(transformed_data, axis=0)
    explained_variance_ratio = explained_variance / np.sum(explained_variance)
    explained_variance_ratio = np.sort(explained_variance_ratio)[::-1]
    return explained_variance_ratio

def sparse_pca(X, n):
    spca = SparsePCA(n_components=n)
    spca_transform = spca.fit_transform(X)
    ex_var_ratio = compute_explained_variance_ratio(spca_transform)
    return spca_transform, ex_var_ratio


I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Q3. How many dimensions can capture more than 99% variance of the baseline rCBF values (using PCA)?

One. The first principal component captures 99.73% variance. But here three dimensions are kept for further analysis.
Can you write Python code for it?

pca_base, ex_var_ratio = pca(df_base.get_values(), 3)
plot(ex_var_ratio)


I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Q4. How many dimensions can capture more than 99% variance of the concentration rCBF values (using PCA)?

One. The first principal component captures 99.79% variance. But here three dimensions are kept for further analysis.
Can you write Python code for it?

pca_concen, ex_var_ratio = pca(df_concen.get_values(), 3)
plot(ex_var_ratio)

# Put everything together
df_lds = pd.DataFrame(spca_lds)
df_base = pd.DataFrame(pca_base)
df_concen = pd.DataFrame(pca_concen)
df_reduced = pd.concat([df_patient, df_lds, df_base, df_concen], axis=1)

# Reduced ADHD and Bipolar features
df_adhd = df_reduced.loc[df_reduced['Patient_ID'].isin(adhd_id)].drop(['Patient_ID'], axis=1)
df_bipolar = df_reduced.loc[df_reduced['Patient_ID'].isin(bipolar_id)].drop(['Patient_ID'], axis=1)

print 'Reduced ADHD sample size:', df_adhd.shape
print 'Reduced Bipolar sample size:', df_bipolar.shape


I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Q5. Are the reduced features from the ADHD and Bipolar samples drawn from the same continuous distribution?
Kolmogorov-Smirnov Goodness-of-Fit Test
Use K-S test to test if 2 independent samples (ADHD and Bipolar) are drawn from the same continuous distribution. All 20 features (resulted from the dimensionality reduction) are tested.
Can you write Python code for it?

from scipy.stats import pearsonr
from scipy.stats import chisquare
from scipy.stats import ks_2samp
from scipy.stats import anderson_ksamp
from skbio.stats.power import subsample_power

pearsonr_test = lambda x: pearsonr(x[0], x[1])[1]
chi_test = lambda x: chisquare(x[0], x[1])[1]
ks_test = lambda x: ks_2samp(x[0], x[1])[1]
anderson_ksamp_test = lambda x: anderson_ksamp(x)[2]

# Computer power of a sub sample set
def compute_sub_power(test, samples):
    pwr, counts = subsample_power(test=test,
                                   samples=samples,
                                   max_counts=300,
                                   min_counts=30,
                                   counts_interval=10,
                                   draw_mode="ind",
                                   alpha_pwr=0.05)
    return pwr, counts


I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Sample from the reduced data and plot power curves
Can you write Python code for it?

from mpl_toolkits.axes_grid1 import Grid

plt.close('all')
fig = plt.figure()
fig.set_size_inches(11, 8.5)

grid = Grid(fig, rect=111, nrows_ncols=(4, 5),
            axes_pad=0.25, label_mode='L',
            )

def plot_power(i, ax):
    a, b = adhd[i], bipolar[i]
    samples = [np.array(a), np.array(b)]
    pwr, counts = compute_sub_power(ks_test, samples)
    ax.plot(counts, pwr.mean(0))

for i, ax in enumerate(grid):
    if i < 20:
        plot_power(i, ax)
        title = 'p = ' + str(p_vals[i])
        ax.set_title(title)

plt.tight_layout()


I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Therefore, use Sparse PCA to reduce the dimension of the LDS questionnaire instead, keep 10 dimensions only.
Can you write Python code for it?

spca_lds, ex_var_ratio = sparse_pca(df_lds.get_values(), 10)
plot(ex_var_ratio)


I am working on the file "Code/Assignment-8/extended_analysis_ADHD_Bipolar_yatbear.ipynb".
The first task is:
Thus, number of features are reduced from 457 to 20.
Can you write Python code for it?

# Have a look at the distribution of reduced data
df_adhd.plot(kind='hist', alpha=0.5, legend=None, title='ADHD After Dimension Reduction')
df_bipolar.plot(kind='hist', alpha=0.5, legend=None, title='Bipolar After Dimension Reduction')


I am working on the file "Code/Assignment-9/GenderDistinguished_ADHD_Bipolar_YatingJing.ipynb".
The first task is:
Classification
Can you write Python code for it?

from sklearn import cross_validation
from sklearn.cross_validation import KFold

def train_test_clf(clf, clf_name, X, y, k=10):
    '''
    Train and test a classifier using # K-fold cross validation
    Args:
        clf: sklearn classifier
        clf_name: classifier name (for printing)
        X: training data (2D numpy matrix)
        y: labels (1D vector)
        k: number of folds (default=10)
    '''
    kf = KFold(len(X), n_folds=k)
    scores = cross_validation.cross_val_score(clf, X, y, cv=kf)
    acc, acc_std = scores.mean(), scores.std()
    print clf_name + ' accuracy is %0.4f (+/- %0.3f)' % (acc, acc_std)
    return acc, acc_std

from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import LinearSVC, SVC
from sklearn.lda import LDA
from sklearn.qda import QDA
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import AdaBoostClassifier

def classify(X, y, gender, feature_type):
    lg = LogisticRegression(penalty='l2')
    knn = KNeighborsClassifier(n_neighbors=7)
    svc = LinearSVC()
    lda = LDA()
    qda = QDA()
    rf = RandomForestClassifier(n_estimators=30)
    gb = GradientBoostingClassifier(n_estimators=20, max_depth=3)
    et = ExtraTreesClassifier(n_estimators=40, max_depth=5)
    ada = AdaBoostClassifier()

    classifiers = [lg, knn, svc, lda, qda, rf, gb, et, ada]
    clf_names = ['Logistic Regression', 'KNN', 'Linear SVM', 'LDA', 'QDA', \
                 'Random Forest', 'Gradient Boosting', 'Extra Trees', 'AdaBoost']
    accuracies = list()

    for clf, name in zip(classifiers, clf_names):
        acc, acc_std = train_test_clf(clf, name, X, y)
        accuracies.append(acc)

    # Visualize classifier performance
    x = range(len(accuracies))
    width = 0.6/1.5
    plt.bar(x, accuracies, width)

    # Compute chance
    n0, n1 = y.count(0), y.count(1)
    chance =...


I am working on the file "Code/Assignment-9/GenderDistinguished_ADHD_Bipolar_YatingJing.ipynb".
The first task is:
Gender 1 ADHD v.s. Bipolar Analysis
Can you write Python code for it?

%matplotlib inline
import matplotlib.pyplot as plt

plot = df1_all.plot(kind='hist', alpha=0.5, title='Gender 1 Data Distribution', legend=None)

# Cluster Gender 1 rCBF features
kmeans(df1_all, 'Gender 1')

# PCA
X1_pca = pca(df1_all, 20)

# LLE
X1_lle = lle(df1_all, 20)

# Classification using PCA features
print 'Using PCA features:'
classify(X1_pca, y1, 'Gender 1', 'PCA')

# Classification using LLE features
print 'Using LLE features:'
classify(X1_lle, y1, 'Gender 1', 'LLE')


I am working on the file "Code/Assignment-9/GenderDistinguished_ADHD_Bipolar_YatingJing.ipynb".
The first task is:
Gender 2 ADHD v.s. Bipolar Analysis
Can you write Python code for it?

plot = df2_all.plot(kind='hist', alpha=0.5, title='Gender 2 Data Distribution', legend=None)

# Cluster Gender 2 rCBF features
kmeans(df2_all, 'Gender 2')

# PCA
X2_pca = pca(df2_all, 20)

# LLE
X2_lle = lle(df2_all, 20)

# Classification using PCA features
print 'Using PCA features:'
classify(X2_pca, y2, 'Gender 2', 'PCA')

# Classification using LLE features
print 'Using LLE features:'
classify(X2_lle, y2, 'Gender 2', 'LLE')


I am working on the file "Code/Assignment-9/Independent Analysis-2.ipynb".
The first task is:
Clustering and other grouping experiments
Can you write Python code for it?

ADHD_clust = pd.DataFrame(ADHD)
BP_clust = pd.DataFrame(BP)

# This is a consequence of how we dropped columns, I apologize for the hacky code
data = pd.concat([ADHD_clust, BP_clust])


I am working on the file "Code/Assignment-9/Independent Analysis-2.ipynb".
The first task is:
we've now dropped the last of the discrete numerical inexplicable data, and removed children from the mix
Extracting the samples we are interested in
Can you write Python code for it?

# Let's extract ADHd and Bipolar patients (mutually exclusive)

ADHD = X.loc[X['ADHD'] == 1]
ADHD = ADHD.loc[ADHD['Bipolar'] == 0]

BP = X.loc[X['Bipolar'] == 1]
BP = BP.loc[BP['ADHD'] == 0]

print ADHD.shape
print BP.shape

# Keeping a backup of the data frame object because numpy arrays don't play well with certain scikit functions
ADHD = pd.DataFrame(ADHD.drop(['Patient_ID', 'Age', 'ADHD', 'Bipolar'], axis = 1, inplace = False))
BP = pd.DataFrame(BP.drop(['Patient_ID', 'Age', 'ADHD', 'Bipolar'], axis = 1, inplace = False))

print ADHD.shape
print BP.shape


I am working on the file "Code/Assignment-9/Independent Analysis-3.ipynb".
The first task is:
Classification Experiments
Let's experiment with a bunch of classifiers
Can you write Python code for it?

ADHD_iso = pd.DataFrame(ADHD_clust)
BP_iso = pd.DataFrame(BP_clust)

BP_iso['ADHD-Bipolar'] = 0
ADHD_iso['ADHD-Bipolar'] = 1
print BP_iso.columns
data = pd.DataFrame(pd.concat([ADHD_iso, BP_iso]))
class_labels = data['ADHD-Bipolar']
data = data.drop(['ADHD-Bipolar'], axis = 1, inplace = False)
print data.shape
data_backup = data.copy(deep = True)
data = data.get_values()

# Based on instructor suggestion i'm going to run a PCA to examine dimensionality reduction
pca = PCA(n_components = 2, whiten = "True").fit(data)
data = pca.transform(data)
print sum(pca.explained_variance_ratio_)

# Leave one Out cross validation
def leave_one_out(classifier, values, labels):
    leave_one_out_validator = LeaveOneOut(len(values))
    classifier_metrics = cross_validation.cross_val_score(classifier, values, labels, cv=leave_one_out_validator)
    accuracy = classifier_metrics.mean()
    deviation = classifier_metrics.std()
    return accuracy, deviation

svc = SVC(gamma = 2, C = 1)
bc = BaggingClassifier(n_estimators = 22)
gb = GradientBoostingClassifier()
dt = DecisionTreeClassifier(max_depth = 22)
qda = QDA()
gnb = GaussianNB()
vc = VotingClassifier(estimators=[('gb', gb), ('bc', bc), ('gnb', gnb)],voting='hard')
classifier_accuracy_list = []
classifiers = [(gnb, "Gaussian NB"), (qda, "QDA"), (svc, "SVM"), (bc, "Bagging Classifier"),
               (vc, "Voting Classifier"), (dt, "Decision Trees")]
for classifier, name in classifiers:
    accuracy, deviation = leave_one_out(classifier, data, class_labels)
    print '%s accuracy is %0.4f (+/- %0.3f)' % (name, accuracy, deviation)
    classifier_accuracy_list.append((name, accuracy))


I am working on the file "Code/Assignment-9/Independent Analysis-3.ipynb".
The first task is:
On data post dimensionality reduction
Can you write Python code for it?

X = data
y = class_labels

X1 = sm.add_constant(X)
est = sm.OLS(y, X1).fit()

est.summary()


I am working on the file "Code/Assignment-9/Independent Analysis-3.ipynb".
The first task is:
we've now dropped the last of the discrete numerical inexplicable data, and removed children from the mix
Extracting the samples we are interested in
Can you write Python code for it?


I am working on the file "Code/Assignment-9/Independent Analysis.ipynb".
The first task is:
As is evident above, the 2 manifold techniques don't really offer very different dimensionality reductions. Therefore we are just going to roll with Multi dimensional scaling
Clustering and other grouping experiments
Mean-Shift - mds
Can you write Python code for it?

ADHD_clust = pd.DataFrame(ADHD_mds)
BP_clust = pd.DataFrame(BP_mds)

# This is a consequence of how we dropped columns, I apologize for the hacky code
data = pd.concat([ADHD_clust, BP_clust])

# Let's see what happens with Mean Shift clustering
bandwidth = estimate_bandwidth(data.get_values(), quantile=0.2, n_samples=1823) * 0.8
ms = MeanShift(bandwidth=bandwidth)
ms.fit(data.get_values())
labels = ms.labels_

cluster_centers = ms.cluster_centers_
labels_unique = np.unique(labels)
n_clusters_ = len(labels_unique)
print('Estimated number of clusters: %d' % n_clusters_)

for cluster in range(n_clusters_):
    ds = data.get_values()[np.where(labels == cluster)]
    plt.plot(ds[:,0], ds[:,1], '.')
    lines = plt.plot(cluster_centers[cluster, 0], cluster_centers[cluster, 1], 'o')


I am working on the file "Code/Assignment-9/Independent Analysis.ipynb".
The first task is:
As is evident from the above 2 experiments, no clear clustering is apparent.But there is some significant overlap and there 2 clear groups
Classification Experiments
Let's experiment with a bunch of classifiers
Can you write Python code for it?

ADHD_mds = pd.DataFrame(ADHD_mds)
BP_mds = pd.DataFrame(BP_mds)

BP_mds['ADHD-Bipolar'] = 0
ADHD_mds['ADHD-Bipolar'] = 1

data = pd.concat([ADHD_mds, BP_mds])
class_labels = data['ADHD-Bipolar']
data = data.drop(['ADHD-Bipolar'], axis = 1, inplace = False)
print data.shape
data = data.get_values()

# Leave one Out cross validation
def leave_one_out(classifier, values, labels):
    leave_one_out_validator = LeaveOneOut(len(values))
    classifier_metrics = cross_validation.cross_val_score(classifier, values, labels, cv=leave_one_out_validator)
    accuracy = classifier_metrics.mean()
    deviation = classifier_metrics.std()
    return accuracy, deviation

p_val = 100
knn = KNeighborsClassifier(n_neighbors = 5)
svc = SVC(gamma = 2, C = 1)
rf = RandomForestClassifier(n_estimators = 22)
dt = DecisionTreeClassifier(max_depth = 22)
qda = QDA()
gnb = GaussianNB()
classifier_accuracy_list = []
classifiers = [(knn, "KNN"), (svc, "SVM"), (rf, "Random Forest"), (dt, "Decision Tree"),
               (qda, "QDA"), (gnb, "Gaussian NB")]
for classifier, name in classifiers:
    accuracy, deviation = leave_one_out(classifier, data, class_labels)
    print '%s accuracy is %0.4f (+/- %0.3f)' % (name, accuracy, deviation)
    classifier_accuracy_list.append((name, accuracy))


I am working on the file "Code/Assignment-9/Independent Analysis.ipynb".
The first task is:
Multi dimensional scaling
Can you write Python code for it?

mds = manifold.MDS(20).fit_transform(combined_backup)
ADHD_mds = combined[:1383]
BP_mds = combined[1383:]
print pd.DataFrame(ADHD_mds).head()


I am working on the file "Code/Assignment-9/Independent Analysis.ipynb".
The first task is:
Though I'm not sure how to tweak the hyper-parameters of the bandwidth estimation function, there doesn't seem to be much difference. Minute variations to the bandwidth result in large cluster differences. Perhaps the data isn't very suitable for a contrived clustering technique like Mean-Shift. Therefore let us attempt something more naive and simplistic like K-Means
K-Means clustering - mds
Can you write Python code for it?

kmeans = KMeans(n_clusters=2)
kmeans.fit(data.get_values())
labels = kmeans.labels_
centroids = kmeans.cluster_centers_
print('Estimated number of clusters: %d' % len(centroids))
print data.shape

for label in [0, 1]:
    ds = data.get_values()[np.where(labels == label)]
    plt.plot(ds[:,0], ds[:,1], '.')
    lines = plt.plot(centroids[i,0], centroids[i,1], 'o')


I am working on the file "Code/Assignment-9/Independent Analysis.ipynb".
The first task is:
We see here that most of the variance is preserved with just 24 features.
Manifold Techniques
ISOMAP
Can you write Python code for it?

combined = manifold.Isomap(20, 20).fit_transform(combined_backup)
ADHD_iso = combined[:1383]
BP_iso = combined[1383:]
print pd.DataFrame(ADHD_iso).head()


I am working on the file "Code/Assignment-9/Independent Analysis.ipynb".
The first task is:
we see here that there 1383 people who have ADHD but are not Bipolar and 440 people who are Bipolar but do not have ADHD
Dimensionality reduction
PCA
Can you write Python code for it?

combined = pd.concat([ADHD, BP])
combined_backup = pd.concat([ADHD, BP])

pca = PCA(n_components = 24, whiten = "True").fit(combined)
combined = pca.transform(combined)
print sum(pca.explained_variance_ratio_)

combined = pd.DataFrame(combined)

ADHD_reduced_df = combined[:1383]
BP_reduced_df = combined[1383:]

ADHD_reduced_df_id = ADHD_reduced_df.copy(deep = True)
BP_reduced_df_id = BP_reduced_df.copy(deep = True)

ADHD_reduced_df_id['Patient_ID'] = 123
BP_reduced_df_id['Patient_ID'] = 123

print ADHD_reduced_df.shape
print BP_reduced_df.shape

print ADHD_reduced_df_id.shape
print BP_reduced_df_id.shape

# resorting to some hacky crap, that I am ashamed to write, but pandas is refusing to cooperate
z = []
for x in BP_df['Patient_ID']:
    z.append(x)
BP_reduced_df_id['Patient_ID'] = z

z = []
for x in ADHD_df['Patient_ID']:
    z.append(x)
ADHD_reduced_df_id['Patient_ID'] = z

ADHD_pca = ADHD_reduced_df.copy(deep = True)
BP_pca = BP_reduced_df.copy(deep = True)


I am working on the file "Code/Assignment-9/Independent Analysis.ipynb".
The first task is:
we've now dropped the last of the discrete numerical inexplicable data, and removed children from the mix
Extracting the samples we are interested in
Can you write Python code for it?

# Let's extract ADHd and Bipolar patients (mutually exclusive)

ADHD = X.loc[X['ADHD'] == 1]
ADHD = ADHD.loc[ADHD['Bipolar'] == 0]

BP = X.loc[X['Bipolar'] == 1]
BP = BP.loc[BP['ADHD'] == 0]

print ADHD.shape
print BP.shape

# Keeping a backup of the data frame object because numpy arrays don't play well with certain scikit functions
ADHD_df = ADHD.copy(deep = True)
BP_df = BP.copy(deep = True)
ADHD = pd.DataFrame(ADHD.drop(['Patient_ID'], axis = 1, inplace = False))
BP = pd.DataFrame(BP.drop(['Patient_ID'], axis = 1, inplace = False))


I am working on the file "Code/Assignment-9/SubjectSelectionExperiments.ipynb".
The first task is:
As is evident from the above 2 experiments, no clear clustering is apparent.But there is some significant overlap and there 2 clear groups
Classification Experiments
Let's experiment with a bunch of classifiers
Can you write Python code for it?

ADHD_men_iso = pd.DataFrame(ADHD_men_iso)
BP_men_iso = pd.DataFrame(BP_men_iso)

ADHD_cauc_iso = pd.DataFrame(ADHD_cauc_iso)
BP_cauc_iso = pd.DataFrame(BP_cauc_iso)

BP_men_iso['ADHD-Bipolar'] = 0
ADHD_men_iso['ADHD-Bipolar'] = 1

BP_cauc_iso['ADHD-Bipolar'] = 0
ADHD_cauc_iso['ADHD-Bipolar'] = 1

data1 = pd.concat([ADHD_men_iso, BP_men_iso])
data2 = pd.concat([ADHD_cauc_iso, BP_cauc_iso])
class_labels1 = data1['ADHD-Bipolar']
class_labels2 = data2['ADHD-Bipolar']
data1 = data1.drop(['ADHD-Bipolar'], axis = 1, inplace = False)
data2 = data2.drop(['ADHD-Bipolar'], axis = 1, inplace = False)
data1 = data1.get_values()
data2 = data2.get_values()

# Leave one Out cross validation
def leave_one_out(classifier, values, labels):
    leave_one_out_validator = LeaveOneOut(len(values))
    classifier_metrics = cross_validation.cross_val_score(classifier, values, labels, cv=leave_one_out_validator)
    accuracy = classifier_metrics.mean()
    deviation = classifier_metrics.std()
    return accuracy, deviation

rf = RandomForestClassifier(n_estimators = 22)
qda = QDA()
lda = LDA()
gnb = GaussianNB()
classifier_accuracy_list = []
classifiers = [(rf, "Random Forest"), (lda, "LDA"), (qda, "QDA"), (gnb, "Gaussian NB")]
for classifier, name in classifiers:
    accuracy, deviation = leave_one_out(classifier, data1, class_labels1)
    print '%s accuracy is %0.4f (+/- %0.3f)' % (name, accuracy, deviation)
    classifier_accuracy_list.append((name, accuracy))

for classifier, name in classifiers:
    accuracy, deviation = leave_one_out(classifier, data2, class_labels2)
    print '%s accuracy is %0.4f (+/- %0.3f)' % (name, accuracy, deviation)
    classifier_accuracy_list.append((name, accuracy))


I am working on the file "Code/Assignment-9/SubjectSelectionExperiments.ipynb".
The first task is:
Clustering and other grouping experiments
K-Means clustering - iso
Can you write Python code for it?

data1 = pd.concat([pd.DataFrame(ADHD_men_iso), pd.DataFrame(BP_men_iso)])
data2 = pd.concat([pd.DataFrame(ADHD_cauc_iso), pd.DataFrame(BP_cauc_iso)])

print data1.shape
print data2.shape

kmeans = KMeans(n_clusters=2)
kmeans.fit(data1.get_values())
labels1 = kmeans.labels_
centroids1 = kmeans.cluster_centers_
print('Estimated number of clusters: %d' % len(centroids1))

for label in [0, 1]:
    ds = data1.get_values()[np.where(labels1 == label)]
    plt.plot(ds[:,0], ds[:,1], '.')
    lines = plt.plot(centroids1[label,0], centroids1[label,1], 'o')

kmeans = KMeans(n_clusters=2)
kmeans.fit(data2.get_values())
labels2 = kmeans.labels_
centroids2 = kmeans.cluster_centers_
print('Estimated number of clusters: %d' % len(centroids2))

for label in [0, 1]:
    ds2 = data2.get_values()[np.where(labels2 == label)]
    plt.plot(ds2[:,0], ds2[:,1], '.')
    lines = plt.plot(centroids2[label,0], centroids2[label,1], 'o')


I am working on the file "Code/Assignment-9/SubjectSelectionExperiments.ipynb".
The first task is:
The change from last week was that we also threw out
Can you write Python code for it?

# Let's now clean columns getting rid of certain columns that might not be important to our analysis

cols2drop = ['GROUP_ID', 'doa', 'Baseline_header_id', 'Concentration_header_id',
             'Baseline_Reading_id', 'Concentration_Reading_id']
X = X.drop(cols2drop, axis=1, inplace=False)
print X.shape

# For our studies children skew the data, it would be cleaner to just analyse adults
X = X.loc[X['Age'] >= 18]
Y = X.loc[X['race_id'] == 1]
X  = X.loc[X['Gender_id'] == 1]

print X.shape
print Y.shape


I am working on the file "Code/Capitulo_2-Exploración.ipynb".
The first task is:
Con la muestra de datos que se define en Ingresos_2, la idea es procesarla y explorar los datos. Esto de manera sencilla implica conocer los tipos de variables, que ya se hizo con el comando info(). Pero lo que se puede buscar es hacer un análisis exploratorio sencillo. Esto tanto de manera gráfica, como de manera de estruturas de datos. Para revisar las posibles relaciones entre los montos y los años o alguna otra variable, se hace uso de agrupaciones. Con esto se hace cierto resumen entre las variables.
Can you write Python code for it?

#Para responder ¿cuál es el año con mayor monto registrado? se hace la siguente agrupación.
Grupo_1=Ingresos_2.groupby('CICLO')

#La cantidad de registros para cada año
Grupo_1.size()

Grupo_1.sum()


I am working on the file "Code/Capitulo_2-Exploración.ipynb".
The first task is:
La misma idea se puede hacer con respecto a los meses para conocer como se comportan los montos. Esto ayuda a responder la pregunta, *¿qué mes tiene la media más alta en montos?
Can you write Python code for it?

Grupo_2=Ingresos_2.groupby('MES')

#La cantidad de registros en cada mes
Grupo_2.size()

Grupo_2.mean()


I am working on the file "Code/Capitulo_2-Exploración.ipynb".
The first task is:
Los anteriores ejemplos, muestran como resolver preguntas sencillas donde se involugra algun variable categórica y su relación con otra numérica. Se pueden hacer agrupaciones más sofisticadas, donde se buscar ver la relación de más de 2 variables; ejemplo de Ciclo, Mes y Sector.
Un poco de exploración gráfica
Lo que se puede hacer con los ejemplos anteriores; las agrupaciones, es mostrar ejemplos de como explorar gráficamente las muestras de datos procesadas y los datos originales. La única finalidad de las siguientes gráficas es explorar el comportamiento de los datos, sin tener una pregunta a investigar de manera inicial.
Can you write Python code for it?

Grupo_1['MONTO'].agg([np.size,sum,max,min])

#El comportamiento entre máximo y mínimos
Grupo_1['MONTO'].agg([max,min]).plot(kind='bar')

#Se explora como se comporta la agrupación por mes por medio de una gráfica de barras.
Grupo_2['MONTO'].agg([max,min,np.mean])

#Los datos originales, permiten explorar gráficamente como se relacionan los valors de los montos con respecto a los meses.
sns.barplot(data=Ingresos_2,x="MES",y="MONTO",palette="PRGn")

#También se puede explorar con los datos agrupados por Año-Mes el comportamiento de los máximos, mínimos y la media de los montos

Grupo_3['MONTO'].agg([max,min,np.mean]).plot(title='Comportamiento de la suma de los Montos')


I am working on the file "Code/Capitulo_2-Exploración.ipynb".
The first task is:
Para elegir los 5 registros con los montos más alta, hacemos la siguiente selección al Grupo_3
Can you write Python code for it?

Grupo_3.sum().sort_values(by='MONTO')[-5:]

#Se puede revisar como se comporta por CICLO y SECTOR, elegimos los 15 registros con valor más
# alto en la suma de su MONTO
Ingresos_2.groupby(['CICLO','SECTOR']).sum().sort_values(by='MONTO')[-15:]

#Graficamos el resultado anterior.
Ingresos_2.groupby(['CICLO','SECTOR']).sum().sort_values(by='MONTO')[-15:].plot(kind='bar')


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
El DataFrame queda sin NaN, ahora lo que falta es explorar cuantos registros quedan por cada año para elegir una muestra anual y luego definir el rango de años que se analizarán o explorarán.
Can you write Python code for it?

#Visualizo cuantas filas y columnas se tienen por cada año.
for i in range(1995,2015):
    print " En el año",i, "se tiene ",Brecha[Brecha['Periodo']==i].shape,"número de filas y columnas, respectivamente."

for i in range(1995,2015):
    print " En el año",i, "se tiene ",Informalidad[Informalidad['Periodo']==i].shape,"número de filas y columnas, respectivamente."


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
El tipo de datos como se cargan los datos por medio de Pandas se visualiza con el sigueinte comando:
~~~python
Brecha.info()
~~~
Se observa que en el entorno de trabajo, el tipo 'object', que son algo así como tipo 'string' en un contexto de bases de datos o sql. Así que para poder procesar la información hago el cambio a tipo de datos numérico. En la tabla "Informalidad" no hago ningún cambio, los datos quedan cargados con el tipo de datos que se requiere para el análisis.
Can you write Python code for it?

#Cambio el tipo de datos a numérico
Brecha['PEA_M']=pd.to_numeric(Brecha['PEA_M'],errors='coercion')
Brecha['PET_M']=pd.to_numeric(Brecha['PET_M'],errors='coercion')
Brecha['TNP_M']=pd.to_numeric(Brecha['TNP_M'],errors='coercion')
Brecha['PEA_H']=pd.to_numeric(Brecha['PEA_H'],errors='coercion')
Brecha['PET_H']=pd.to_numeric(Brecha['PET_H'],errors='coercion')
Brecha['TNP_H']=pd.to_numeric(Brecha['TNP_H'],errors='coercion')

#Reviso el nuevo tipo de dato
Brecha.info()

#Se visualizan de nuevo los primeros 5 registros de los datos
Brecha.head()


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
En este caso lo que haré es eliminar todos los datos NaN de la tabla Brecha, y revisar la cantidad de registros que se tienen por año.
Can you write Python code for it?

#Se define otra DataFrame sin datos NaN
Brecha=Brecha.dropna()

Brecha.isnull().sum()


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Es interesante ver como en Coahuila, Colima, Guanajuato, Jalisco, México, Nuevo León y Sonora la población de mujeres trabajan mucho más en informalidad que los hombres.
Agrupando por dos índices, tanto por Género como por grupo de edad, se tienen lo siguiente:
Can you write Python code for it?


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Pese a que se ve medio asobronada la gráfica, se observa que el estado de Cuahuila, Colima, Guanajuato, Jalisco, Nuevo León, Puebla, Sonora y Zacatecas muestran que el grupo de mujeres con edad mayor de 30 años sobre pasan la informalidad de manera muy considerable con respecto a los hombres.
Ahora para ver como se comportan las 4 distribuciones de los indicadores de trabajos informales, hago un histograma para cada una de las variables.
Can you write Python code for it?

#Las siguientes instrucciones permiten generar una gráfica de los histogramas de las 4 variables
#hago uso de las gráficas "nativas" de pandas para mostrar el ejemplo, pero se pueden correr el
#código de abajo y se obtienen un resultado "similar".
#plt.style.use('bmh')
#plt.hist(Informalidad_1998.TInfSecFor,histtype="stepfilled",bins=15, alpha=0.7, normed=True)
#plt.hist(Informalidad_1998.TSecInf,histtype="stepfilled",bins=15, alpha=0.7, normed=True)
#plt.hist(Informalidad_1998.TAgroInf,histtype="stepfilled",bins=15, alpha=0.7, normed=True)
#plt.hist(Informalidad_1998.TDomesInf,histtype="stepfilled",bins=15, alpha=0.7, normed=True)
#plt.legend(['Trabajo Informal en Sector Formal','Trabajo Sector Informal','Trabajo Agro Informal','Trabajo Doméstico Informal'])
#plt.show()
Informalidad_1998[['TInfSecFor','TSecInf','TAgroInf','TDomesInf']].plot(kind='hist',stacked=True,bins=15,alpha=0.7)


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Revisando las columnas, se ve que cuatro columnas corresponden a trabajos informales y la última a la población ocupada laboralmente en la entidad, en el género y rango de edades. Con un poco de cuidado, la tabla se muestra como si los datos estuvieran agrupados por año, entidad, género y rango de edad. Entonces lo primero que hago es contruir una columna con el porcentaje que representan las poblaciones en trabajos informales y luego construyo una tabla donde la información sea "desagrupada".
Can you write Python code for it?

#Se contruye porcentaje de población en trabajos imformales, se agrega una nueva columna. Se usa el método loc[] para operar
#sobre las columnas, para revisar detalles de esto se puede consultar en la libra siguiente
#http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy

Valores=np.sum(Informalidad_1998.loc[:,('TAgroInf','TSecInf','TInfSecFor','TDomesInf')],axis=1)
Valores=Valores/Informalidad_1998.loc[:,('Pob_Ocup_T')]
Informalidad_1998.loc[:,'Porcentaje']=Valores
del(Valores)

Informalidad_1998.head()

#Gráfica por Grupo de Edad
import sys
reload(sys)
sys.setdefaultencoding('utf8') # Lo modifico el encoding del sistema para poder escribir los títulos con acentos.

Informalidad_1998.pivot_table(values='Porcentaje',index=['Grupo_Edad'],columns=['Sexo']).plot(kind='barh',title='Porcentaje de informalidad por Género')


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se aprecia que la tabla "Brecha" cuenta con datos ND, pero antes de limpiar el archivo  o quitar los missing data, exploro el tipo de datos de cada columna.
Can you write Python code for it?


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se observa en la gráfica que casi la mitad (17) de las entidades muestran un predominio por la tasa neta de participación femenil en el rango de edad de 15 a 29 años. Por otro lado, algunos estados o entidades muestran una tasa casi igual para las dos categorías.
Cambio la estructura del DataFrame usando la función melt(), esta en ayuda a cambiar la estructura de la tabla de datos es simular a la función melt() del paquete reshape2 de R. La razones de porqué cambiar la estructura de la tabla son diversas, depende mucho de lo que uno esté explorando cómo uno quiere tener la relación entre las variables. En este caso es solo un ejemplo para contruir los boxplot y ver como se comporta la Tasa Neta de parcitipación separada por género.
Can you write Python code for it?

#Se contruye un nuevo DataFrame
L=pd.melt(Brecha_1998[['Entidad','Grupo_Edad','TNP_M','TNP_H']],id_vars=['Entidad','Grupo_Edad'],var_name='Tasa Neta Participación')
L.head()

#Cargo otro módulo para no tener problemas con el encoding que se tiene en el sistema
#Se construye el Boxplot para los datos de DataFrame modificado
sns.boxplot(x="Tasa Neta Participación",y="value", data=L)


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se observa que el DataFrame L2 tienen las 4 variables y una más que es el Grupo de Edad, una herramienta gráfica para analizar la posible relación entre las variables es hacer un gráfico scatterplot. El siguiente gráfico es el ejemplo.
Can you write Python code for it?

#Se genera el scatter plot de las variables
sns.pairplot(L2[["TNP_M","TNP_H","Hombres_Informalidad","Mujeres_Informalidad"]])


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se observa que en la tabla Informalidad se tiene el doble de filas por año, esto debido a que se tienen medidas por género. Elijo para explorar inicialmente los datos en el año 1998 y uso de  muestra de datos los correspondientes a los años 2000-2014 para hacer un análisis más detallado.
Análisis del año 1998
Construyo dos DataFrame con los cuales analizo los datos en el año 1998, cada uno correspondiente a los datos de la tabla Brecha e Informalidad.
Can you write Python code for it?

Informalidad_1998=Informalidad[Informalidad['Periodo']==1998]

#Reviso los primeros 10 registros
Informalidad_1998.head(7)


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se observa que las distribuciones son de "tipo cola pesada", los valores que se muestran en el eje "y" es la frecuencia de los datos. Pero esto deja ver a grandes razgos como se comportan las medidas de los trabajos informales.
Explorando un poco el comportamiento de los datos de la  Brecha laborales entre género, eligo los correspondientes al año 1998.
Can you write Python code for it?

#Se eligen los datos del año 1998 de la Brecha
Brecha_1998=Brecha[Brecha['Periodo']==1998]

#Se visualizan los primeros registros de los datos
Brecha_1998.head()


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se observa que las dos primeras filas corresponden a los datos Nacionales correspondientes al año 1998, para el análisis elimino esas dos filas.
Can you write Python code for it?

#Se eliminan las primeras dos lineas o filas para analizados los datos, ya que son el resumen de los datos a nivel nacional.
Brecha_1998=Brecha_1998.iloc[2:,:]
Brecha_1998.head()

Brecha_1998.pivot_table(values='TNP_M', index=['Entidad'], columns=['Grupo_Edad']).plot(kind='bar')


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se observa que para las dos categorías de Hombres y Mujeres, después de los 30 años la media de los porcentajes es casi igual, por otro lado cuando tienen menos de 30 años los hombres se integran a trabajos informales con mayor cantidad.
Can you write Python code for it?

#Por Género y Entidad Federativa
Informalidad_1998.pivot_table(values='Porcentaje',index=['Entidad'],columns=['Sexo']).plot(kind='bar')


I am working on the file "Code/Capitulo_5.-Informalidad laboral y brecha entre las tasas netas de participacion femenina y masculina. Parte1.ipynb".
The first task is:
Se observa solo una posible relación lineal entre los datos correspondientes a las tasas de informalidad, esto se observa en las gráficas correspondientes a las variables Hombres_Informalidad vs Mujeres_Informalidad.
Ahora contruyo una DataFrame más, en el cual agrego tanto las variables que se tienen en L2, como un par de variables dummies para representar el Grupo de Edad. La gráfica anterior puede modificarse al considerar el comportamiento de las variables por alguna de las variables dumies.
Can you write Python code for it?

#Se contruyen el nuevo DataFrame
L4=pd.concat([L2,pd.get_dummies(L2.Grupo_Edad)],axis=1)
L4.columns=['Entidad','Grupo_Edad','TNP_M','TNP_H','Mujeres_Informalidad','Hombres_Informalidad','De_15_a_29','De_30_y_más']
L4.head()

#Visualización del comportamiento de las variables con respecto al primero grupo de edad
sns.pairplot(L4[["TNP_M","TNP_H","Hombres_Informalidad","Mujeres_Informalidad","De_15_a_29"]],hue="De_15_a_29")


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
Como cargar un json y analizarlo.
En la siguiente se da una ejemplo de como cargar datos desde algún servicio web que regresa un arvhivo de tipo JSON.
Can you write Python code for it?

sns.factorplot(x="ENTIDAD",y="MUJERES_INSC_ING",hue="CICLO",data=datos,palette="muted", size=15,kind="bar")

#Otra gráfica, se muestra el cruce entre las mujeres  que se inscriben en ingeniería y el total de mujeres
with sns.axes_style('white'):
    sns.jointplot('MUJERES_INSC_ING','MAT_TOTAL_SUP',data=datos,kind='hex')


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
El ejemplo anterior muestra el uso de Numpy como una biblioteca o módulo que permite hacer manipulación de matrices y como la calidad del procesamiento numérico perminte considarar su uso en problemas de métodos numéricos.
Problema del laberito con Numpy
El problema tiene el mismo nombre que un ejemplo del uso del algoritmo Backtracking para solución de problemas por "fuerza bruta", respecto a esa técnica se puede consultar el brog de JC Gómez.
El ejemplo que comparto tienen que ver más con el uso de Cadenas de Markov, el ejemplo es solo para mostrar como funcionan y como se hace uso de ellas para resolver el problema con ciertos supuestos iniciales y como hacerlo con numpy.
Suponemos que se colocará un dispositivo que se puede desplazar y pasar de área como en el cuadro siguiente: La idea es que puede pasar del cuadro 1 hacia el 2 o el 4, si empieza en el cuadro 2 puede pasar del 1 al 3, pero si inicia en el 5 solo puede pasar al 6, etc.
Entonces lo que se plantea es que si inicia en el cuadro 1 y pasa al 2, eso solo depende de haber estado en el cuadro 1, si se pasa al cuadro 3 solo depende del estado 2, no de haber estado en el estado 1. Entonces la idea de los procesos de Markov es que para conocer si se pasará al cuadro 3 iniciando en el cuadro 1 solo se requiere conocer los pasos previos.
En lenguaje de probabilidad se expresa así:
\begin{align}
 P(X_{n}|X_{n-1},X_{n-2},...,X_{1}) = P(X_{n}|X_{n-1})\\[5pt]
\end{align}
Entonces los supuestos son que se tienen 6 posibles estados iniciales o lugares desde donde iniciar, el cuadro 1 hasta el cuadro 6. Se hace una matriz que concentra la información ordenada de la relación entre los posibles movimientos entre cuadros contiguos. Entonces la relación de estados es:
\begin{align}
 p_{ij}= P(X_{n}=j|X_{n-1}=i)\\[5pt]
\end{align}
Donde se refiere a la probabilidad de estar en el cuadro j si se estaba en el estado i, para el cuadro 2 las probabilidades serían:
\begin{align}
 p_{21}= P(X_{n}=1|X_{n-1}=2)\\[5pt]
 p_{23}= P(X_{n}=3|X_{n-1}=2)\\[5pt]
      0=...
Can you write Python code for it?


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
El ejemplo anterior tiene 3 vectores propios y 3 valores propios, pero no refleja el problema en general de la relación entre las páginas web, ya que podría suceder que una página no tienen referencias a ninguan otra salvo a si misma o tienen solo referencias a ella y ella a ninguna, ni a si misma. Entonces un caso más general sería representado como el gráfo siguiente:

En el grafo se tiene un nodo D y E, los cuales muestran un comportamiento que no se reflejaba en el grafo anterior. El nodo E y D no tienen salidas a otros nodos o páginas.
La matriz asociada para este gráfo resulta ser la siguiente:
\begin{array}{ccccc}
.33 & .25 & 0.5 & 0 & 0 \
.33 & 0 & 0 & 0 & 0 \
.33 & .25 & 0 & 0 & 0\
 0 & .25 & 0.5  & 1 & 0\
 0 & .25 & 0 & 0 & 1 \end{array}
Se observa que para esta matriz no cada columna tienen valor 1, ejemplo la correspondiente a la columna D tienen todas sus entradas 0. Entonces el algoritmo de PageRank propone modificar la matriz adyacencia y agregarle una matriz que la compensa.
La ecuación del siguiente modo:
\begin{align}
     A=\betaM + (1-\beta)\frac{1}{n}ee^T
\end{align}
Lo que sucede con esta ecuación, es que las columnas como la correspiente el nodo D toman valores que en suma dan 1, en caso como el nodo E se "perturban" de modo que permite que el algoritmo no se quede antorado en ese tipo de nodos. Si se considera la misma hipótesis de que inicialmente se tienen la misma probabilidad de estar en cualquiera de las páginas (nodos) entonces se considera ahora solo un vector de tamaño 5 en lugar de 3, el cual se vería así:
\begin{align}
     v=(.33,.33,.33,.33,.33)\
\end{align}
El coeficiente beta toma valores de entre 0.8 y 0.9, suelen considerarse 0.85 su valor o por lo menos es el que se suponía se usaba por parte de Google, en resumen este parámetros es de control. La letra e representa un vector de a forma v=(1,1,1,1,1), el producto con su traspuesta genera una matriz cuadrada la cual al multiplicarse por 1/n tiene una matriz de Markov.
La matriz A ya es objeto de poder calcular el vector...
Can you write Python code for it?

from __future__ import division
import numpy as np

#Se definen los calores de las constantes de control y las matrices requeridas
beta=0.85

#Matriz adyacente
M=np.matrix([[0.33,0.25,0.5,0,0],[.33,0,0,0,0],[0.33,0.25,0,0,0],[0,.25,.5,1,0],[0,.25,0,0,1]])

#Cantidad de nodos
n=M.shape[1]

#Matriz del modelo de PageRank
A=beta*M+((1-beta)*(1/n)*np.ones((5,5)))

#Se define el vector inicial del ranking
v=np.ones(5)/5

#Proceso de estimación por iteracciones
iterN=1

while True:
    v1=v
    v=v.dot(M)
    print "Interación %d\n" %iterN
    print v
    if not np.any((0.00001<np.abs(v-v1))):
            break
    else:
     iterN=iterN+1

print "M*v\n"
v.dot(M)


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
Nota: para estre breve análisis se hace uso de la construcción de tablas pivot en pandas. Esto facilidad analizar como se comportan las variables categóricas de los datos. En este ejemplo se muestra que el periódo 2010/2011 tuvo una media mayor de mujeres inscritas en ingeniarías, pero también se ve que la relación entre los estados fue más dispersa. Pero también se ve que los periódos del 2011/2012, 2012/2013 y 2013/2014 tienen comportamientos "similares".
Otras herramientas gráficas
Conforme evolucionó Pandas y el módulo se volvió más usado, la límitante que tenía a mi parecer, era el nivel de gráficos base. Para usar los DataFrame y Series en matplotlib se necesita definir los array o procesarlos de modo tal que puedan contruirse mejores gráficos. Matplotlib es un módulo muy potente, pero resulta mucho más engorroso hacer un análisis grafico. Si se ha usado R project para hacer una exploración de datos, resulta muy facil constrir los gráficos básicos y con librerías como ggplot2 o lattice se puede hacer un análisis gráfico sencillo y potente.
Ante este problema se diseño una librería para complementar el análisis grafico, que es algo asi como "de alto nivel" al comprarla con matplotlib. El módulo se llama seaborn.
Para los siguientes ejemplos uso los datos que se han analizado anteriormente.
Can you write Python code for it?

#Se construye la tabla
#Tabla1=datos.pivot('ENTIDAD','CICLO','MUJERES_INSC_ING')
datos.head()

#Se carga la librería seaborn
import seaborn as sns
#sns.set(style="ticks")
#sns.boxplot(x="CICLO",y="MUJERES_INSC_ING",data=datos,palette="PRGn",hue="CICLO")


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
Observación: se vuelve evidente que las entidades federales o Estados donde se inscriben más mujeres a ingenierías son el Distrito Federal(Ciudad de México), Estado de México, Veracruz, Puebla, Guanajuato, Jalisco y Nuevo León. También se observa que en todos los estados en el periódo 2010/2011 la cantidad de mujeres que se inscribieron fue mayor y decayó significativamente en los años siguientes.
Esto responde a la pregunta : ¿cuál es el estado que presenta mayor cantidad de inscripciones de mujeres a ingeniería?
Can you write Python code for it?

#Se grafica el boxplot para cada periodo
datos.pivot('ENTIDAD','CICLO','MUJERES_INSC_ING').plot(kind='box', title='Boxplot')


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
Para ver un ejemplo de su uso, realiza lo siguiente:
*  Se define las regiones x e y.
*  Se define un polinomio para probar la definición de la región.
*  Se utiliza la función region_estabilidad y se grafica el resultado.
Can you write Python code for it?

#Se define la región
x = np.linspace(-3.0, 1.5)
y = np.linspace(-3.0, 3.0)
X, Y = np.meshgrid(x, y)

#Se define el polinomio
def p(w):
       return [1, -1 - w - w ** 2 / 2 - w ** 3 / 6 - w ** 4 / 24]

Z = region_estabilidad(p, X, Y)
%matplotlib inline
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize']=(20,7)
plt.contour(X, Y, Z, np.linspace(0.0, 1.0, 9))
plt.show()


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
Se tienen como resultado que en 17 iteraciones el algoritmo indica que el PageRank no es totalmente dominado por el nodo E y D, pese a que son las "páginas" que tienen mayor valor, pero las otras 3 resultan muy cercanas en importancia. Se aprecia como se va ajustando el valor conforme avanzan las etapas de los cálculos.
Data.Frame y Series
Los dos elementos principales de Pandas son Data.Frame y Series. El nombre Data.Frame es igual que el que se usa en R project y en escencia tiene la misma finalidad de uso, para la carga y procesamiento de datos.
Los siguientes ejemplos son breves, para conocer con detalle las propiedades, operaciones y caracteristicas que tienen estos dos objetos se puede consultar el libro Python for Data Analysis o el sitio oficial del módulo Pandas.
Primero se carga el módulo y los objetos y se muestran como usarlos de manera sencilla.
Can you write Python code for it?

#Se carga el módulo
import pandas as pd
from pandas import Series, DataFrame

#Se construye una Serie, se agregan primero la lista de datos y después la lista de índices
datos_series=Series([1,2,3,4,5,6],index=['a','b','c','d','e','f'])

#Se muestra como carga los datos Pandas en la estrutura definida
datos_series

#Se visualizan los valores que se guardan en la estructura de datos
datos_series.values

#Se visualizan los valores registrados como índices
datos_series.index

#Se seleccionan algún valor asociado al índice 'b'
datos_series['b']

#Se revisa si tienen datos nulos o NaN
datos_series.isnull()

#Se calcula la suma acumulada, es decir 1+2,1+2+3,1+2+3+4,1+2+3+4+5,1+2+3+4+5+6
datos_series.cumsum()

#Se define un DataFrame, primero se define un diccionario y luego de genera el DataFrame
datos={'Estado':['Guanajuato','Querétaro','Jalisco','Durango','Colima'],'Población':[5486000,1828000,7351000,1633000,723455],'superficie':[30607,11699,78588,123317,5627]}
Datos_Estados=DataFrame(datos)

Datos_Estados

#Se genrea de nuevo el DataFrame y lo que se hace es asignarle índice para manipular los datos
Datos_Estados=DataFrame(datos,index=[1,2,3,4,5])

Datos_Estados

#Se selecciona una columna
Datos_Estados.Estado

#Otro modo de elegir la columna es del siguiente modo.
Datos_Estados['Estado']

#Se elige una fila, y se hace uso del índice que se definió para los datos
Datos_Estados.ix[2]

#Se selecciona más de una fila
Datos_Estados.ix[[3,4]]

#Descripción estadística en general, la media, la desviación estándar, el máximo, mínimo, etc.
Datos_Estados.describe()

#Se modifica el DataFrame , se agrega una nueva columna
from numpy import nan as NA
Datos_Estados['Índice']=[1.0,4.0,NA,4.0,NA]

Datos_Estados

#Se revisa si hay datos NaN o nulos
Datos_Estados.isnull()

#Pandas cuenta con herramientas para tratar los Missing Values, en esto se pueden explorar como con isnull() o
#eliminar con dropna. En este caso de llena con fillna
Datos_Estados.fillna(0)


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
Si se procede ha seguir incrementando los estados o cambios se "estabiliza"; es decir, el cambio en la probabilidad de estar en la caja 1 después de tercer movimiento es 37.53%, lo cual tiende a quedarse en 37.5% al incrementar los movimientos.
Ejemplo de PageRank de manera rupestre, calcuado con Numpy
El algoritmo para generar un Ranking en las páginas web fue desarrollado e implementado por los fundadores de Google, no profundizo en los detalles pero en general la idea es la siguiente:

Representar la Web como un gráfo dirigido.
Usar la matriz asociada a un grafo para analizar el comportamiento de la web bajo ciertos supuestos.
Agregar al modelo base lo necesario para que se adapate a la naturaleza de la web de mejor manera.

El primer objetivo es representar cada página como un vértice de un grafo y una arista representa la relación de la página a otra página; es decir, si dentro de la página A se hace referencia a la página B, entonces se agrega una "flecha", por lo tanto un ejemplo sencillo lo representa el siguiente grafo:

La imagen anterior representa un gráfo donde se simula que hay relación entre 3 páginas, la flecha indica el direccionamiento de una página a otra. Entonces para modelar la relación entre las páginas lo que se usa es matriz de adyacencia, esta matriz concentra la información de las relaciones entre nodos. La matriz adyacente de ese gráfo sería como:
\begin{array}{ccc}
.33 & .5 & 1 \
.33 & 0 & 0 \
.33 & .5 & 0 \end{array}
Esta matriz es una matriz de Markov por columnas, cada una suma 1, el objetivo es que se tenga un vector con el ranking del orden de las páginas por prioridad al iniciar la búsqueda en internet y después de hacer uso de la matriz se puede conocer cual es el orden de prioridad.
Así que suponiendo que cualquiera de las 3 páginas tienen la misma probabilidad de ser la página inicial, se tienen que el vector inicial es:
\begin{align}
     v=(.33,.33,.33)\
\end{align}
Después de usar la matriz la ecuación que nos permitiría conocer el mejor ranking de las páginas...
Can you write Python code for it?

import numpy as np
M=np.matrix([[.33,.5,1],[.33,0,0],[.33,.5,0]])
lambda1,v=np.linalg.eig(M)
lambda1,v


I am working on the file "Code/Capítulo_1-Carga_Pandas.ipynb".
The first task is:
Viendo los datos que se tienen, es natural preguntarse algo al respecto. Lo sencillo es, ¿cuál es el estado que presenta mayor cantidad de inscripciones de mujeres a ingeniería?, pero también se puede agregar a la pregunta anterior el preguntar en qué año o cíclo ocurrió eso.
Algo sencillo para abordar las anteriores preguntas construir una tabla que permita visualizar la relación entre las variables mencionadas.
Can you write Python code for it?

#Se construye una tabla pivot para ordenar los datos y conocer como se comportó el total de mujeres
#inscritas a ingenierías
datos.pivot('ENTIDAD','CICLO','MUJERES_INSC_ING')

#Se revisa cual son los 3 estados con mayor cantidad de inscripciones en el cíclo 2012/2013
datos.pivot('ENTIDAD','CICLO','MUJERES_INSC_ING').sort_values(by='2012/2013')[-3:]

#Se grafican los resultados de la tabla anterior, pero ordenadas por el cíclo 2010/2011
datos.pivot('ENTIDAD','CICLO','MUJERES_INSC_ING').sort_values(by='2010/2011').plot(kind='bar')


I am working on the file "Code/Capítulo_3-Comportamiento de los puertos.ipynb".
The first task is:
De la tabla anterior se puede revisar la relación entre Guaymas y Mazatlan, la cual es considerable para revisar estadísticamente con más cuidado. Considerando las ubicaciones geográficas de los 3 puertos, es curioso que la Paz muestra correlación negativa y con Guaymas positiva, quizás relaciones comerciales o de cercanía que salen fuera de este breve análisis.
Otra cosa que se puede revisar es la relación entre las tasas de porcentaje para todos los puertos, posible no es tan parecida a los 3 que se revisaron.
Can you write Python code for it?

#Por último se puede visualizar la relación de las medianas de los porcentajes para cada uno de los puertos.
Puertos.groupby('Marina Fonatur').median().plot(kind='bar')


I am working on the file "Code/Capítulo_3-Comportamiento de los puertos.ipynb".
The first task is:
La gráfica muestra que después de Febrero 2015 se registra una "alza", tanto en la ocupación de marina seca, como en muelles y boyas. Pero también se observa como entre Diciembre 2014 y Enero 2015 hay una baja muy considerable en el porcentaje de ocupación en general.
Solo por curiosidad, se puede pensar en hacer el "cruce" entre los porcentajes, para ver su posible relación. Esto solo lo hago gráficamete, pero se puede calcular también la correlación entre ellos.
Can you write Python code for it?

#La correlación entre los dos porcentajes es de .312287, bastante bajo.
Mazatlan.corr()

#Lo anterior gráficamente se puede visualizar con una gráfica que cuente con los histogramas y el scatterplot.
sns.jointplot(x="Porcentaje de ocupacion muelles y boyas",y="Porcentaje de ocupacion marina seca",data=Mazatlan,kind="reg")


I am working on the file "Code/Capítulo_3-Comportamiento de los puertos.ipynb".
The first task is:
Lo primero que trato de explorar es la cantidad de puertos considerados, para poder elegir entre ellos los 3 que tienen la mediana mayor de los porcentajes de ocupación.
Can you write Python code for it?

#Se elige la columna Marina Fonatur y se eliminan los duplicados para conocer la cantidad de puertos registrados en los datos.
Puertos['Marina Fonatur'].drop_duplicates()


I am working on the file "Code/Capítulo_3-Comportamiento de los puertos.ipynb".
The first task is:
Los puertos analizar o explorar, son Mazatlan, La Paz y Guaymas. Para conocer como se comportan el porcentaje por fecha para todos los puertos se contruye una tabla pivot.
Can you write Python code for it?

#Tabla pivor para ver el comportamiento de todos los puertos
Puertos.pivot_table(values='Porcentaje de ocupacion muelles y boyas',columns='Marina Fonatur',index='Fecha')


I am working on the file "Code/Capítulo_3-Comportamiento de los puertos.ipynb".
The first task is:
Se observa que la última fial tiene un NaN para la Paz, así que en la revisión correspondiente lo tomaré en cuanta. La tabla anterior puede graficarse directamente, solo se agrega plot() al final de la construcción de la tabla.
Can you write Python code for it?

#Se grafica la tabla pivot
Puertos.pivot_table(values='Porcentaje de ocupacion muelles y boyas',columns='Marina Fonatur',index='Fecha').plot()

#Se contruye la tabla y luego solo se eligen los 3 puertos a revisar.
Tabla1=Puertos.pivot_table(values='Porcentaje de ocupacion muelles y boyas',columns='Marina Fonatur',index='Fecha')
Tabla1[['Mazatlan','La Paz','Guaymas']]

#En la línea morada se observa que al final, en el último punto falta un valor, esto es por el NaN
Tabla1=Tabla1[['Mazatlan','La Paz','Guaymas']]
Tabla1.plot()

#Sustituimos el valor del Nan, si volvemos a graficar ya se muestra la línea morada con un dato en la última fecha.b
Tabla1=Tabla1.fillna(Tabla1.mean())
Tabla1.plot()


I am working on the file "Code/Capítulo_4-Eficiancia_Terminal.ipynb".
The first task is:
Al nuevo DataFrame se le agrega una columna nueva, la finalidad es concentrar los datos en una sola tabla.
Can you write Python code for it?

#Se agrega una nueva columna a los datos
Tabla['Etsup']=Eficiencia.Etsup

#Se visualizan los primeros registros del DataFrame
Tabla.head()

#Se agrupan los datos y tomo las medianas de los dos porcentajes, tanto el de inscripción de mujeres a ingeniería
#como el porcentaje de eficiencia teminal.
Tabla.groupby('CICLO').median()


I am working on the file "Code/Capítulo_4-Eficiancia_Terminal.ipynb".
The first task is:
Inicialmente esperaba que las dos barras por cada estado tuvieran valor positivo o negativo, pero no hay una razón real detras de mi supuesto inicial. Uno de los problemas es que se normalizan todos los datos sin importar el  ciclo, esto afecta en la "escala" pero no en la "forma", lo intensante sería normalizar los 32 registros de cada ciclo para ver como se comportan por cada ciclo. Como ejemplo reviso el comportamiento del ciclo 2010/2011.
Can you write Python code for it?

Tabla_2010_2011=Tabla[Tabla.CICLO=='2010/2011']

Tabla_2010_2011['Z_Mujeres']=(Tabla_2010_2011.P_MUJERES_EN_ING - Tabla_2010_2011.P_MUJERES_EN_ING.mean())/(Tabla_2010_2011.P_MUJERES_EN_ING.std())

#Todos los registros del 2010/2011
Tabla_2010_2011.head(32)

#Gráfica para visualizar que la modificación que se tiene al normalizar todos los datos o solo los correspondientes al ciclo
Tabla_2010_2011[['Z_Mujeres','Z_MUJERES_ING']].plot()


I am working on the file "Code/Capítulo_4-Eficiancia_Terminal.ipynb".
The first task is:
Para tener una "idea" visual de lo que está pasando con los datos o como se comportan, hago una gráfica de barras con respecto a los años.
Can you write Python code for it?

#Gráfica de barras
Tabla.groupby('CICLO').median().plot(kind='bar')


I am working on the file "Code/Capítulo_4-Eficiancia_Terminal.ipynb".
The first task is:
Para tratar de revisar la "posible" relación entre las dos tasas de porcentaje hago el ejercicio de "normalizar" los valores, estos es "centrar" los datos y "dividir" por la desviación estándar. No explico los detalles técnicas, solo hago esto para poder tener un marco comparativo entre las dos tasas.
Nota: Lo que hago es un análisis ilustrativo, por lo cual no entro en detalles estadísticos serios. No es la finalidad de esta exploración.
Can you write Python code for it?

#Cambio el nombre a las columnas, para quitarle el caracter '%' a la tasa de mujeres inscritas en ingeniería.
Tabla.columns=['ENTIDAD','CICLO','P_MUJERES_EN_ING','Etsup']

#Normalizo los datos y los agrego a una nueva columna en el DataFrame.
Tabla['Z_MUJERES_ING']=(Tabla.P_MUJERES_EN_ING-Tabla.P_MUJERES_EN_ING.mean())/(Tabla.P_MUJERES_EN_ING.std())

#Normalizo los datos de eficiencia terminal y los agrego a una nueva columna.
Tabla['Z_Etsup']=(Tabla.Etsup-Tabla.Etsup.mean())/Tabla.Etsup.std()

Tabla.head()

#Hago una visualización de las variables o columnas normalizadas.
Tabla.groupby('CICLO')[['Z_MUJERES_ING','Z_Etsup']].median().plot(kind='bar')


I am working on the file "Code/Capítulo_4-Eficiancia_Terminal.ipynb".
The first task is:
Se observa que los estados con mejor eficiencia terminal en todos los ciclos son Durango y Querétaro.En cada ciclo hay 3 estados relevantes con casi el 100% de eficiencia.
Can you write Python code for it?

#Valores enteros del porcentaje de mujeres en ingeniería
Tabla['E_MUJERES']=Tabla.P_MUJERES_EN_ING.apply(int)

#Se contruye la tabla
Tabla_2=Tabla.pivot(index='ENTIDAD',columns='CICLO',values='E_MUJERES')

#Se contruye el mapa de calor.
sns.heatmap(Tabla_2,annot=True,linewidths=.5)


I am working on the file "Code/Capítulo_4-Eficiancia_Terminal.ipynb".
The first task is:
Se observa que tienen el mismo tipo de datos y lo único que falta revisar es la cantidad de periodos, ya que se observa en la información de cada tabla que la de Mujeres cuanta con 168 líneas y las de Eficiencia solo 128. Reviso los ciclos que se consideran en los datos.
Can you write Python code for it?


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Add datetime and quarter columns
Can you write Python code for it?

all_facility_data['datetime'] = pd.to_datetime(all_facility_data['year'].astype(str) +
                                               '-' + all_facility_data['month'].astype(str),
                                               format='%Y-%m')
all_facility_data['quarter'] = all_facility_data['datetime'].dt.quarter

#drop
all_facility_data.head()


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Apply emission factors
Fuel emission factor is kg/mmbtu
Can you write Python code for it?

# Start with 0 emissions in all rows
# For fuels where we have an emission factor, replace the 0 with the calculated value
all_facility_data['all fuel fossil CO2 (kg)'] = 0
all_facility_data['elec fuel fossil CO2 (kg)'] = 0
all_facility_data['all fuel total CO2 (kg)'] = 0
all_facility_data['elec fuel total CO2 (kg)'] = 0
for fuel in total_factors.keys():
    # All fuel CO2 emissions
    all_facility_data.loc[all_facility_data['fuel']==fuel,'all fuel fossil CO2 (kg)'] = \
        all_facility_data.loc[all_facility_data['fuel']==fuel,'total fuel (mmbtu)'] * fossil_factors[fuel]
    all_facility_data.loc[all_facility_data['fuel']==fuel,'all fuel total CO2 (kg)'] = \
        all_facility_data.loc[all_facility_data['fuel']==fuel,'total fuel (mmbtu)'] * total_factors[fuel]

    # Electric fuel CO2 emissions
    all_facility_data.loc[all_facility_data['fuel']==fuel,'elec fuel fossil CO2 (kg)'] = \
        all_facility_data.loc[all_facility_data['fuel']==fuel,'elec fuel (mmbtu)'] * fossil_factors[fuel]
    all_facility_data.loc[all_facility_data['fuel']==fuel,'elec fuel total CO2 (kg)'] = \
        all_facility_data.loc[all_facility_data['fuel']==fuel,'elec fuel (mmbtu)'] * total_factors[fuel]


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Apply factors to facility generation
Can you write Python code for it?

fossil_factors = dict(zip(ef.index, ef['Fossil Factor']))
total_factors = dict(zip(ef.index, ef['Total Factor']))
fossil_factors, total_factors


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Combine total fuel use for electricity into one large dataframe
Can you write Python code for it?

if __name__ == '__main__':
    exception_list = []
    facility_eg_fuel = pd.concat(Parallel(n_jobs=-1)(delayed(facility_line_to_df)(json.loads(row)) for row in eg_fuel_rows))
    facility_eg_fuel.reset_index(drop=True, inplace=True)
    facility_eg_fuel.rename_axis({'value':'elec fuel (mmbtu)'}, axis=1, inplace=True)

facility_eg_fuel.loc[:,'lat'] = facility_eg_fuel.loc[:,'lat'].astype(float)
facility_eg_fuel.loc[:,'lon'] = facility_eg_fuel.loc[:,'lon'].astype(float)
facility_eg_fuel.loc[:,'plant id'] = facility_eg_fuel.loc[:,'plant id'].astype(int)

#drop
facility_eg_fuel.tail()

#drop
path = os.path.join('Clean data', 'Facility electric fuel consumption.csv')
facility_eg_fuel.to_csv(path, index=False)


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Combine total fuel use into one large dataframe
Can you write Python code for it?

if __name__ == '__main__':
    exception_list = []
    facility_all_fuel = pd.concat(Parallel(n_jobs=-1)(delayed(facility_line_to_df)(json.loads(row)) for row in total_fuel_rows))
    facility_all_fuel.reset_index(drop=True, inplace=True)
    facility_all_fuel.rename_axis({'value':'total fuel (mmbtu)'}, axis=1, inplace=True)

facility_all_fuel.loc[:,'lat'] = facility_all_fuel.loc[:,'lat'].astype(float)
facility_all_fuel.loc[:,'lon'] = facility_all_fuel.loc[:,'lon'].astype(float)
facility_all_fuel.loc[:,'plant id'] = facility_all_fuel.loc[:,'plant id'].astype(int)

#drop
facility_all_fuel.head()

#drop
path = os.path.join('Clean data', 'Facility total fuel consumption.csv')
facility_all_fuel.to_csv(path, index=False)


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Fill in missing values from the first merge
Can you write Python code for it?

def fill_missing(df):
    cols = [col[:-2] for col in df.columns if '_x' in col]

    # Create new column from the _x version, fill missing values from the _y version
    for col in cols:
        df[col] = df.loc[:, col + '_x']
        df.loc[df[col].isnull(), col] = df.loc[df[col].isnull(), col + '_y']

        df.drop([col+'_x', col+'_y'], axis=1, inplace=True)

fill_missing(gen_total_fuel)

#drop
gen_total_fuel.loc[gen_total_fuel['geography'].isnull()]

keep_cols = ['fuel', 'elec fuel (mmbtu)', 'month', 'plant id', 'prime mover', 'year',
             'geography', 'lat', 'lon', 'last_updated']
all_facility_data = gen_total_fuel.merge(facility_eg_fuel.loc[:,keep_cols],
                                         how='outer', on=merge_cols)


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Load emission factors
These are mostly EIA emission factors
Can you write Python code for it?

path = os.path.join('Clean data', 'Final emission factors.csv')
ef = pd.read_csv(path, index_col=0)


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Read ELEC.txt file
Can you write Python code for it?

path = os.path.join('Raw data', 'Electricity data', '2017-03-15 ELEC.txt')
with open(path, 'rb') as f:
    raw_txt = f.readlines()


I am working on the file "Code/EIA Bulk Download - extract facility generation.ipynb".
The first task is:
Reload dataframes from files
Goal is to merge the fuel use and fuel use for electricity back into the generation dataframe
Can you write Python code for it?

#drop
path1 = os.path.join('Clean data', 'Facility generation.csv')
path2 = os.path.join('Clean data', 'Facility total fuel consumption.csv')
path3 = os.path.join('Clean data', 'Facility electric fuel consumption.csv')

#drop
facility_gen = pd.read_csv(path1)

#drop
facility_gen.head()

#drop
facility_all_fuel = pd.read_csv(path2)

#drop
facility_eg_fuel = pd.read_csv(path3)


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
All generation by fuel
Can you write Python code for it?

gen_df = pd.concat([line_to_df(json.loads(row)) for row in gen_rows])

#drop
gen_df.head()


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Combine three datasets
Need to estimate fuel use for OOG, because EIA doesn't include any (this is only ~2% of OOG fuel for electricity in 2015).
Can you write Python code for it?

merge_cols = ['type', 'year', 'month']

fuel_df = total_fuel_df.merge(eg_fuel_df[merge_cols+['elec fuel (mmbtu)']],
                              how='outer', on=merge_cols)
fuel_df.head()


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Electric generation fuel consumption
Can you write Python code for it?

eg_fuel_df = pd.concat([line_to_df(json.loads(row)) for row in eg_fuel_rows])

#drop
eg_fuel_df.head()


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Export data
Can you write Python code for it?

path = os.path.join('Clean data', 'EIA country-wide gen fuel CO2.csv')
gen_fuel_df.to_csv(path, index=False)


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Filter lines to only include total generation and fuel use
Only want monthly US data for all sectors
- US-99.M
- ELEC.GEN, ELEC.CONS_TOT_BTU, ELEC.CONS_EG_BTU
- not ALL
Fuel codes:
- WWW, wood and wood derived fuels
- WND, wind
- STH, solar thermal
- WAS, other biomass
- TSN, all solar
- SUN, utility-scale solar
- NUC, nuclear
- NG, natural gas
- PEL, petroleum liquids
- SPV, utility-scale solar photovoltaic
- PC, petroluem coke
- OTH, other
- COW, coal,
- DPV, distributed photovoltaic
- OOG, other gases
- HPS, hydro pumped storage
- HYC, conventional hydroelectric
- GEO, geothermal
- AOR, other renewables (total)
Can you write Python code for it?

def line_to_df(line):
    """
    Takes in a line (dictionary), returns a dataframe
    """
    for key in ['latlon', 'source', 'copyright', 'description',
                'geoset_id', 'iso3166', 'name', 'state']:
        line.pop(key, None)

    # Split the series_id up to extract information
    # Example: ELEC.PLANT.GEN.388-WAT-ALL.M
    series_id = line['series_id']
    series_id_list = series_id.split('.')
    # Use the second to last item in list rather than third
    plant_fuel_mover = series_id_list[-2].split('-')
    line['type'] = plant_fuel_mover[0]
#     line['state'] = plant_fuel_mover[1]
    line['sector'] = plant_fuel_mover[2]
    temp_df = pd.DataFrame(line)

    try:
        temp_df['year'] = temp_df.apply(lambda x: x['data'][0][:4], axis=1).astype(int)
        temp_df['month'] = temp_df.apply(lambda x: x['data'][0][-2:], axis=1).astype(int)
        temp_df['value'] = temp_df.apply(lambda x: x['data'][1], axis=1)
        temp_df.drop('data', axis=1, inplace=True)
        return temp_df
    except:
        exception_list.append(line)
        pass

exception_list = []
gen_rows = [row for row in raw_txt if 'ELEC.GEN' in row and 'series_id' in row and 'US-99.M' in row and 'ALL' not in row]
total_fuel_rows = [row for row in raw_txt if 'ELEC.CONS_TOT_BTU' in row and 'series_id' in row and 'US-99.M' in row and 'ALL' not in row]
eg_fuel_rows = [row for row in raw_txt if 'ELEC.CONS_EG_BTU' in row and 'series_id' in row and 'US-99.M' in row and 'ALL' not in row]


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Match general types with specific fuel codes
Fuel codes:
- WWW, wood and wood derived fuels
- WND, wind
- STH, solar thermal
- WAS, other biomass
- TSN, all solar
- SUN, utility-scale solar
- NUC, nuclear
- NG, natural gas
- PEL, petroleum liquids
- SPV, utility-scale solar photovoltaic
- PC, petroluem coke
- OTH, other
- COW, coal,
- DPV, distributed photovoltaic
- OOG, other gases
- HPS, hydro pumped storage
- HYC, conventional hydroelectric
- GEO, geothermal
- AOR, other renewables (total)
Can you write Python code for it?

#drop
ef.loc['NG', 'Fossil Factor']

fuel_factors = {'NG' : ef.loc['NG', 'Fossil Factor'],
                   'PEL': ef.loc[['DFO', 'RFO'], 'Fossil Factor'].mean(),
                   'PC' : ef.loc['PC', 'Fossil Factor'],
                   'COW' : ef.loc[['BIT', 'SUB'], 'Fossil Factor'].mean(),
                   'OOG' : ef.loc['OG', 'Fossil Factor']}

#drop
fuel_factors

# Start with 0 emissions in all rows
# For fuels where we have an emission factor, replace the 0 with the calculated value
gen_fuel_df['all fuel CO2 (kg)'] = 0
gen_fuel_df['elec fuel CO2 (kg)'] = 0
for fuel in fuel_factors.keys():
    gen_fuel_df.loc[gen_fuel_df['type']==fuel,'all fuel CO2 (kg)'] = \
        gen_fuel_df.loc[gen_fuel_df['type']==fuel,'total fuel (mmbtu)'] * fuel_factors[fuel]

    gen_fuel_df.loc[gen_fuel_df['type']==fuel,'elec fuel CO2 (kg)'] = \
        gen_fuel_df.loc[gen_fuel_df['type']==fuel,'elec fuel (mmbtu)'] * fuel_factors[fuel]

gen_fuel_df.loc[gen_fuel_df['type']=='COW',:].head()

#drop
gen_fuel_df.loc[gen_fuel_df['type']=='OOG'].head()


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Multiply generation values by 1,000,000 and change the units to MMBtu
Can you write Python code for it?

total_fuel_df.loc[:,'value'] *= 1E6
total_fuel_df.loc[:,'units'] = 'mmbtu'

total_fuel_df['datetime'] = pd.to_datetime(total_fuel_df['year'].astype(str) + '-' + total_fuel_df['month'].astype(str), format='%Y-%m')
total_fuel_df['quarter'] = total_fuel_df['datetime'].dt.quarter
total_fuel_df.rename_axis({'value':'total fuel (mmbtu)'}, axis=1, inplace=True)

#drop
total_fuel_df.head()

#drop
total_fuel_df.loc[total_fuel_df['type']=='OOG'].head()


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Multiply generation values by 1000 and change the units to MWh
Can you write Python code for it?

gen_df.loc[:,'value'] *= 1000
gen_df.loc[:,'units'] = 'megawatthours'

gen_df['datetime'] = pd.to_datetime(gen_df['year'].astype(str) + '-' + gen_df['month'].astype(str), format='%Y-%m')
gen_df['quarter'] = gen_df['datetime'].dt.quarter
gen_df.rename_axis({'value':'generation (MWh)'}, axis=1, inplace=True)

#drop
gen_df.head()

#drop
gen_df.loc[gen_df['type']=='OOG'].head()


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
No records with positive fuel use but no generation
Can you write Python code for it?


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Not seeing the issue that shows up with facilities, where some facilities have positive total fuel consumption but no elec fuel consumption
Can you write Python code for it?

#drop
fuel_df.loc[~(fuel_df['elec fuel (mmbtu)']>=0)]

gen_fuel_df = gen_df.merge(fuel_df[merge_cols+['total fuel (mmbtu)', 'elec fuel (mmbtu)']],
                           how='outer', on=merge_cols)
gen_fuel_df.head()


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Read ELECT.txt file
Can you write Python code for it?


I am working on the file "Code/EIA bulk download - non-facility (distributed PV & state-level).ipynb".
The first task is:
Total fuel consumption
Can you write Python code for it?

total_fuel_df = pd.concat([line_to_df(json.loads(row)) for row in total_fuel_rows])

#drop
total_fuel_df.head()


I am working on the file "Code/EPA Emissions data.ipynb".
The first task is:
Correct column names and export all files (1 file per year)
Also convert the OP_DATE column to a datetime object
Using joblib for this.
Joblib on windows requires the if name == 'main': statement. And in a Jupyter notebook the function needs to be imported from an external script. I probably should have done the parallel part at a higher level - the longest part is saving the csv files. Could use this method - disable a check - to speed up the process.
Joblib has to be at least version 10.0, which is only available through pip - got some errors when using the version installed by conda.
Create a dictionary mapping column names. Any values on the left (keys) should be replaced by values on the right (values).
Can you write Python code for it?

col_name_map = {'CO2_MASS' : 'CO2_MASS (tons)',
                'CO2_RATE' : 'CO2_RATE (tons/mmBtu)',
                'GLOAD' : 'GLOAD (MW)',
                'HEAT_INPUT' : 'HEAT_INPUT (mmBtu)',
                'NOX_MASS' : 'NOX_MASS (lbs)',
                'NOX_RATE' : 'NOX_RATE (lbs/mmBtu)',
                'SLOAD' : 'SLOAD (1000lb/hr)',
                'SLOAD (1000 lbs)' : 'SLOAD (1000lb/hr)',
                'SO2_MASS' : 'SO2_MASS (lbs)',
                'SO2_RATE' : 'SO2_RATE (lbs/mmBtu)'
                }

from joblib import Parallel, delayed
from scripts import import_clean_epa

if __name__ == '__main__':
    start_time = timeit.default_timer()
    base_path = 'EPA downloads'
    for year in range(2015, 2017):
        print 'Starting', str(year)
        df_list = []
        path = os.path.join(base_path, str(year))
        fnames = os.listdir(path)

        df_list = Parallel(n_jobs=-1)(delayed(import_clean_epa)(path, name, col_name_map) for name in fnames)

        print 'Combining data'
        df = pd.concat(df_list)
        print 'Saving file'
        path_out = os.path.join('Clean data', 'EPA emissions', 'EPA emissions ' + str(year) + '.csv')
        df.to_csv(path_out, index=False)
        print round((timeit.default_timer() - start_time)/60.0,2), 'min so far'

    # Timestamp
    elapsed = round((timeit.default_timer() - start_time)/60.0,2)


I am working on the file "Code/EPA Emissions data.ipynb".
The first task is:
Export file names and update timestamp
Can you write Python code for it?

name_time_df = pd.DataFrame(name_time_list, columns=['file name', 'last updated'])

name_time_df.head()

len(name_time_df)

path = os.path.join('EPA downloads', 'name_time 2015-2016.csv')
name_time_df.to_csv(path, index=False)


I am working on the file "Code/EPA Emissions data.ipynb".
The first task is:
Final script
This downloads hourly data from the ftp server over a range of years, and saves all of the file names/last update times in a list. The downloads can take some time depending on how much data is being retrieved.
Some of the code below assumes that we only need to retrieve new or modified files. If you are retrieving this data for the first time, create an empty dataframe named already_downloaded with column names file name and last updated.
Can you write Python code for it?

# Replace the filename with whatever csv stores already downloaded file info
path = os.path.join('EPA downloads', 'name_time 2015-2016.csv')
already_downloaded = pd.read_csv(path, parse_dates=['last updated'])

# Uncomment the line below to create an empty dataframe
# already_downloaded = pd.DataFrame(columns=['file name', 'last updated'])

already_downloaded.head()

# Timestamp
start_time = timeit.default_timer()
name_time_list = []
# Open ftp connection and navigate to the correct folder
print 'Opening ftp connection'
ftp = FTP('ftp.epa.gov')
ftp.login()
ftp.cwd('/dmdnload/emissions/hourly/monthly')

for year in [2015, 2016, 2017]:
    print year

    year_str = str(year)
    print 'Change directory to', year_str
    try:
        ftp.cwd(year_str)
    except ftplib.all_errors as e:
        print e
        break

    # Use ftplib to get the list of filenames
    print 'Fetch filenames'
    fnames = ftp.nlst()

    # Create new directory path if it doesn't exist
    new_path = os.path.join('EPA downloads', year_str)
    try:
        os.mkdir(new_path)
    except:
        pass

    # Look for files without _HLD in the name
    name_list = []
    time_list = []
    print 'Find filenames without _HLD and time last updated'
    for name in fnames:
        if '_HLD' not in name:
            try:
                # The ftp command "MDTM" asks what time a file was last modified
                # It returns a code and the date/time
                # If the file name isn't already downloaded, or the time isn't the same
                tm = pd.to_datetime(ftp.sendcmd('MDTM '+ name).split()[-1])
                if name not in already_downloaded['file name'].values:

                    time_list.append(tm)
                    name_list.append(name)
                elif already_downloaded.loc[already_downloaded['file name']==name, 'last updated'].values[0] != tm:
                    tm = ftp.sendcmd('MDTM '+ name)
                    time_list.append(pd.to_datetime(tm.split()[-1]))
   ...


I am working on the file "Code/EPA Emissions data.ipynb".
The first task is:
From the table below, recent years always have the units after an emission name. Before 2009 some files have the units and some don't. UNITID is consistent through all years, but UNIT_ID was added in after 2008 (not the same thing).
Can you write Python code for it?

pd.DataFrame(col_names)

pd.DataFrame(col_names).index

pd.DataFrame(num_cols)


I am working on the file "Code/EPA Emissions data.ipynb".
The first task is:
This takes ~100 ms per file.
Can you write Python code for it?

base_path = 'EPA downloads'
num_cols = {}
col_names = {}
for year in range(2001, 2017):

    n_cols_list = []
    col_name_list = []
    path = os.path.join(base_path, str(year))
    fnames = os.listdir(path)

    for name in fnames:
        csv_name = name.split('.')[0] + '.csv'
        fullpath = os.path.join(path, name)
        filehandle = open(fullpath, 'rb')
        zfile = zipfile.ZipFile(filehandle)
        data = StringIO.StringIO(zfile.read(csv_name)) #don't forget this line!
        reader = csv.reader(data)
        columns = reader.next()

        # Add the column names to the large list
        col_name_list.extend(columns)
        # Add the number of columns to the list
        n_cols_list.append(len(columns))

    col_names[year] = Counter(col_name_list)
    num_cols[year] = Counter(n_cols_list)


I am working on the file "Code/Emission factors.ipynb".
The first task is:
Add EPA emission factors for fossil fuels not included in the EIA file
https://www.epa.gov/sites/production/files/2015-07/documents/emission-factors_2014.pdf
- BFG (blast furnace gas)
- MSW (non-biomass portion)
- OG (other gas, assume fuel gas)
Add zero values for all bio fuels. Still need to figure out what to do for synthetic gas from coal and petroleum...
Can you write Python code for it?

ef.loc['BFG',:] = ['Blast Furnace Gas', 274.32, None , 'https://www.epa.gov/sites/production/files/2015-07/documents/emission-factors_2014.pdf']
ef.loc['MSN',:] = ['Non-biomass Municipal Solid Waste', 90.7, 'Assume the same as MSW', 'https://www.epa.gov/sites/production/files/2015-07/documents/emission-factors_2014.pdf']

# Use the bituminous coal factor for synthetic coal
ef.loc['SC',:] = ['Synthetic Coal', 93.3, 'Use same factor as BIT and RC', None]

# Use fuel gas for other gases
ef.loc['OG', :] = ['Other gases', 59, 'Assume fuel gas', 'https://www.epa.gov/sites/production/files/2015-07/documents/emission-factors_2014.pdf']

# Use BIT factor for synthetic gas from coal (SGC) and DFO for SGP
# The actual factors won't matter as much because we're going to use the EPA
# emission values.
ef.loc['SGC', ['Fossil Factor', 'Notes']] = [93.3, 'Using BIT value. Likely not correct']
ef.loc['SGP', ['Fossil Factor', 'Notes']] = [73.16, 'Using DFO value. Likely not correct']

non_fossil_fuels = ['AB', 'BLQ', 'LFG', 'MSB', 'NUC', 'OBG', 'OBL', 'OBS',
                    'OTH', 'PUR', 'SLW', 'SUN', 'WAT', 'WDL', 'WDS', 'WH', 'WND']

for fuel in non_fossil_fuels:
    ef.loc[fuel, ['Fossil Factor', 'Notes']] = [0, 'non-fossil fuel']


I am working on the file "Code/Emission factors.ipynb".
The first task is:
Add non-fossil emission factors for a total emission factor column
Can you write Python code for it?

epa_factor_link = 'https://www.epa.gov/sites/production/files/2015-07/documents/emission-factors_2014.pdf'
ipcc_factor_link = 'http://www.ipcc-nggip.iges.or.jp/public/2006gl/pdf/2_Volume2/V2_2_Ch2_Stationary_Combustion.pdf'
ef['Total Factor'] = ef['Fossil Factor']
ef.loc['BLQ', ['Total Factor', 'Notes', 'Link']] = [94.4, 'Table 6-6, North American Softwood', 'https://www.epa.gov/sites/production/files/2015-03/documents/subpartaa-tsd-pulp_and_paper.pdf']
ef.loc['AB', ['Total Factor', 'Link']] = [118.17, epa_factor_link]
ef.loc['LFG', ['Total Factor', 'Link']] = [52.17, epa_factor_link]
ef.loc['MSB', ['Total Factor', 'Notes', 'Link']] = [90.7, 'Biomass portion of MSW', epa_factor_link]
ef.loc['OBG', ['Total Factor', 'Link']] = [52.17, epa_factor_link]
ef.loc['OBL', ['Total Factor', 'Link']] = [83.98, ipcc_factor_link]
ef.loc['OBS', ['Total Factor', 'Link']] = [105.51, epa_factor_link]
ef.loc[['SLW', 'WDL'], ['Total Factor', 'Notes', 'Link']] = [83.98, 'Assume same as OBL', ipcc_factor_link]
# ef.loc['WDL', ['Total Factor', 'Notes', 'Link']] = [83.98, 'Assume same as OBL', ipcc_factor_link]
ef.loc['WDS', ['Total Factor', 'Link']] = [93.8, epa_factor_link]


I am working on the file "Code/Emission factors.ipynb".
The first task is:
Export
Can you write Python code for it?

path = os.path.join('Clean data', 'Final emission factors.csv')
ef.to_csv(path)

ef


I am working on the file "Code/Extract Gravity Signal.ipynb".
The first task is:
Around sample 10500, the orientation of my phone in the X and Y directions changed because Nick and I swapped phones.
Extracting the gravity signal is largely a matter of applying a low pass filter, since the acceleration due to gravity is not changing with time.
Can you write Python code for it?

# a Gaussian filter with a large window width is essentially a low pass filter
from scipy.ndimage import gaussian_filter

# a window that is too small retains noise from non-gravity signals
# a window that is too large eliminates variations in GravityXYZ due to orientation variations.
windowwidth = 25

# apply the smoothing function and store the results in a new column in the dataframe
temp = gaussian_filter(df['accelerometerAccelerationX'], windowwidth)
df['smoothaccelerometerAccelerationX'] = temp
temp = gaussian_filter(df['accelerometerAccelerationY'], windowwidth)
df['smoothaccelerometerAccelerationY'] = temp
temp = gaussian_filter(df['accelerometerAccelerationZ'], windowwidth)
df['smoothaccelerometerAccelerationZ'] = temp

# plot the result
df[['smoothaccelerometerAccelerationX', 'smoothaccelerometerAccelerationY', 'smoothaccelerometerAccelerationZ']].plot(figsize=(12,4))

# and compare again to the gravity signal
df[['motionGravityX', 'motionGravityY', 'motionGravityZ']].plot(figsize=(12,4))


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
Enumerating the library
A library has an enumerator that determines what reagents are selected for purposes of enumeration.
The default enumerator is a CartesianProduct enumerator, which is a fancy way of saying enumerate everything.  You can get hold this enumerator by using the GetEnumerator method.
Can you write Python code for it?

enumerator = library.GetEnumerator()
print (enumerator)

print ("Possible number of permutations:", enumerator.GetNumPermutations())


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
Enumeration States
Enumerations have states as well, so you can come back later using GetState and SetState
GetState returns a text string so you can save this pretty much anywhere you like.
Let's skip to the 100th sample and save both the state and the product at this step.
Can you write Python code for it?

library = rdChemReactions.EnumerateLibrary(rxn, reagents, params=params)
# skip the first 100 molecules
library.GetEnumerator().Skip(100)
# get the state

state = library.GetState()
print("State is:\n", repr(state))

result = library.next()
for productSet in result:
    for mol in productSet:
        smiles = AllChem.MolToSmiles(mol)
        break


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
If you only want each reactant to match once ( and hence only produce one product per reactant set ) you can adjust the parameters:
Can you write Python code for it?

params = rdChemReactions.EnumerationParams()
params.reagentMaxMatchCount = 1
library = rdChemReactions.EnumerateLibrary(rxn, reagents, params=params)


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
Let's advance by one here and see what happens.  It's no surprise that for the CartesianProduct strategy the first index is increased by one.
Can you write Python code for it?

pos = test_enumerator.next()
print(list(pos))


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
Pickling Libraries
The whole library, including all reagents and the current enumeration state reagents is saved when the library is serialized.
Can you write Python code for it?

s = library.Serialize() # XXX bug need default arg

library2 = rdChemReactions.EnumerateLibrary()
library2.InitFromString(s)


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
Preprocessing Reaction Blocks
You will note that there are some special annotations in the reaction block:
V   1 halogen
V   2 amine.primary

These allows us to specify functional groups with very specific smarts patterns.
These smarts patterns are preloaded into the RDKit, but require the use of PreprocessReactions
to embed the patterns.
Can you write Python code for it?

rxn.Initialize()
nWarn, nError, nReactants, nProducts, labels =  AllChem.PreprocessReaction(rxn)
print ("Number of warnings:", nWarn)
print ("Number of preprocessing errors:", nError)
print ("Number of reactants in reaction:", nReactants)
print ("Number of products in reaction:", nProducts)
print ("Preprocess labels added:", labels)


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
Sanitizing Reaction Blocks
Reaction blocks come from many different sketchers, and some don't follow the MDL conventions very well.  It is always a good idea to sanitize your reaction blocks first.  This is also true for Smiles reactions if they are in kekule form.
Can you write Python code for it?


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
So now, this scaffold will only match the specified halogens and a primary amine.  Let's get some!
Can you write Python code for it?

!wget http://www.sigmaaldrich.com/content/dam/sigma-aldrich/docs/Aldrich/General_Information/1/sdf-benzylic-primary-amines.sdf -O amines.sdf

!wget http://www.sigmaaldrich.com/content/dam/sigma-aldrich/docs/Aldrich/General_Information/1/sdf-alkyl-halides.sdf -O halides.sdf

reagents = [
            [x for x in AllChem.SDMolSupplier("halides.sdf")],
            [x for x in AllChem.SDMolSupplier("amines.sdf")]
        ]

print ("number of reagents per template:", [len(x) for x in reagents])


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
This also appears to be the last product. So lets' start over.
Can you write Python code for it?

library = rdChemReactions.EnumerateLibrary(rxn, reagents, params=params)
test_enumerator = copy.copy(library.GetEnumerator())
list(test_enumerator.GetPosition())


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
Understanding results of enumerations
Each enumeration result may contain multiple resulting molecules.  Consider a reaction setup as follows:
A + B >> C + D
There may be multiple result molecules for a number of reasons:

The reactant templates (A and B) match a reagent multiple times.
     Each match has to analyzed to form a new product.  Hence,
     the result has to be a vector of products.
There me be multiple product templates, i.e. C+D as shown above
     where C and D are two different result templates.  These are
     output in a result as follows: result = enumerator.next()

 result == [ [results_from_product_template1],
             [results_from_product_template2], ... ]

 result[0] == [results_from_product_template1]
 result[1] == [results_from_Product_template2]

Because there may be multiple product templates specified with
potentially multiple matches, iterating through the results to
get to the final molecules isa bit complicated and requires three loops.  Here we use:

result for the result of reacting one set of reagents
productSet for the products for a given product template
mol the actual product

In many reactions, this will result in a single molecule, but the
datastructures have to handle the full set of results:
for result in enumerator:
      for productSet in results:
          for mol in productSet:
Can you write Python code for it?

count = 0
totalMols = 0
for results in library:
    for productSet in results:
        for mol in productSet:
            totalMols += 1
    count += 1
print("Number of result sets", count)
print("Number of result molecules", totalMols)


I am working on the file "Code/GraphMol/ChemReactions/tutorial/EnumerationToolkit.ipynb".
The first task is:
We can Skip to the 100th result
Can you write Python code for it?

test_enumerator.Skip(100)
pos = list(test_enumerator.GetPosition())
print(pos)

reagents[0][pos[0]]

reagents[0][pos[1]]


I am working on the file "Code/IPython/Bootcamp_1_Examples.ipynb".
The first task is:
Answer(s)?  Aren't the boxplots in the last figure cool?  The histograms above them?  What do you see in them?  How do the various returns compare?

Example 3: GDP per capita and life expectancy
The World Bank collects a broad range of economic and social indicators for most countries in the World.  They also have a nice interface.  It's a good source for basic information about the economic climate compares across countries.
We illustrate its usefulness with a scatterplot of life expectancy v GDP per capita.
Question(s).  How closely are these two indicators of quality of life are related.
References

http://data.worldbank.org/
http://pandas.pydata.org/pandas-docs/stable/remote_data.html#world-bank
http://matplotlib.org/examples/shapes_and_collections/scatter_demo.html
Can you write Python code for it?

# load package under name wb
from pandas.io import wb

# find the codes for the variables of interest
wb.search
wb.search(string='gdp.*capita').iloc[:2]

# specify dates, variables, and countries
start = 2011
# GDP per capita, population, life expectancy
variable_list = ['NY.GDP.PCAP.KD', 'SP.POP.TOTL', 'SP.DYN.LE00.IN']
country_list  = ['US', 'FR', 'JP', 'CN', 'IN', 'BR', 'MX']

# Python understands we need to go to the second line because ( hasn't been closed by )
data = wb.download(indicator=variable_list,
                   country=country_list, start=start, end=start).dropna()

# see what we've got
print(data)

# check the column labels, change to something simpler
print(data.columns)
data.columns = ['gdppc', 'pop', 'le']
print(data)

# scatterplot
# life expectancy v GDP per capita
# size of circles controlled by population

# load packages (ignored if redundant)
import numpy as np
import matplotlib.pyplot as plt

plt.scatter(data['gdppc'], data['le'], s=0.000001*data['pop'], alpha=0.5)
plt.ylabel('Life Expectancy')
plt.xlabel('GDP Per Capita')
plt.show()

# Note:  size of circles based on population


I am working on the file "Code/IPython/Bootcamp_1_Examples.ipynb".
The first task is:
Example 1: US GDP Growth
Investors -- and others -- keep a close eye on the state of the economy because it affects the performance of firms and financial assets. We'll go into this more extensively later, but for now we want to see what the economy has done in the past, especially the recent past.  We use the wonderful FRED interface ("API") and load the data straight from their website.  Then we graph GDP growth over the past 50 years or so and for a more recent period of greater interest.
This strategy -- find the data on the web, load it, and produce a graph -- is a model for much of what we do.
Question(s).
It's always good to know what you're looking for so we'll post question(s) for each example.  Here we
ask how the economy is doing, and how its current performance compares to the past.
References

FRED: http://research.stlouisfed.org/fred2/
Pandas: http://pandas.pydata.org/pandas-docs/stable/
Data access: http://pandas.pydata.org/pandas-docs/stable/remote_data.html#fred
Inline plots:  http://stackoverflow.com/questions/21176731/automatically-run-matplotlib-inline-in-ipython-notebook

Note to self:
The FRED API allows you to import transformations like growth rates directly. Is that possible with Pandas?
Can you write Python code for it?

# anything after the hashtag is a comment
# load packages
import datetime as dt
import pandas.io.data as web       # data import tools
import matplotlib.pyplot as plt    # plotting tools

# The next one is an IPython command:  it says to put plots here in the notebook, rather than open a separate window.
%matplotlib inline

# get data from FRED
fred_series = ["GDPC1"]
start_date = dt.datetime(1960, 1, 1)
data = web.DataReader(fred_series, "fred", start_date)

# print last 3 data points to see what we've got
print(data.tail(3))

# compute annual growth rates
g = 4*data.pct_change()

# change label
g.columns = ['US GDP Growth']