I am working on the file "Case - Ecology.ipynb".
The first task is:
Similarly, we will demarcate two further periods: 1945-1969, and 1970-1995.
Can you write Python code for it?

corpus_mid = corpus.subcorpus(('date', range(1945, 1970)))
corpus_late = corpus.subcorpus(('date', range(1970, 1995)))

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

plt.subplot(131)
plt.title('Early')
plt.ylabel('Number of Papers per Year')
plt.bar(*corpus_early.distribution())

plt.subplot(132)
plt.title('Mid')
plt.bar(*corpus_mid.distribution())

plt.subplot(133)
plt.title('Late')
plt.bar(*corpus_late.distribution())

plt.show()


I am working on the file "Case - Ecology.ipynb".
The first task is:
Size (N edges) relative to order (N nodes) gives us a sense of the relative density of the networks.
Can you write Python code for it?

print '1920-1944:', float(coauthor_graph_early.size())/coauthor_graph_early.order()
print '1945-1969:', float(coauthor_graph_mid.size())/coauthor_graph_mid.order()
print '1970-1994:', float(coauthor_graph_late.size())/coauthor_graph_late.order()


I am working on the file "Case - Ecology.ipynb".
The first task is:
The amount of assortativity also seems to be increasing over time.
GraphCollections
Often we're interested in looking at the evolution of a network over time, and it may not be appropriate or desirable to delimit time period ahead of time. GraphCollections give us a nice way to look at networks over continuous time. Essentially, a GraphCollection will use a sliding time-window to subdivide our corpus, and generate a graph from each of those subcorpora (much like we did above). It also indexes the nodes in the graphs, so that we can follow individual nodes over time.
Can you write Python code for it?


I am working on the file "Case - Ecology.ipynb".
The first task is:
The code below fixes a bug in the network-building process. This will be fixed in later versions of Tethne.
Can you write Python code for it?

for g in [graph_bc_early, graph_bc_mid, graph_bc_late]:
    g.name = ''

write_graphml(graph_bc_early, '/Users/erickpeirson/Desktop/graph_bc_early.graphml')

write_graphml(graph_bc_mid, '/Users/erickpeirson/Desktop/graph_bc_mid.graphml')

write_graphml(graph_bc_late, '/Users/erickpeirson/Desktop/graph_bc_late.graphml')


I am working on the file "Case - Ecology.ipynb".
The first task is:
To create the GraphCollection, we provide our Corpus, our network-building method (coauthors in this case), and then some optional parameters. slice_kwargs tells the GraphCollection how to generate the sliding time-window. In this case, we want periods of 6 years, and we want to advance the window 4 years at every step. So each network will represent 6 years of publications, and overlap with the next network by 2 years.
Can you write Python code for it?

G = GraphCollection(corpus, coauthors, slice_kwargs={'window_size': 6, 'step_size': 4})


I am working on the file "Case - Ecology.ipynb".
The first task is:
We see a similar pattern in the average clustering coefficient: the extent of clustering actually decreases at first, and then picks up around the middle of the 1940s.
Can you write Python code for it?

mean_assortativity = zip(*G.analyze('degree_assortativity_coefficient').items())

plt.figure(figsize=(10, 7))

plt.plot(*mean_assortativity, lw=2, c='purple', label='Assortativity coefficient')
plt.plot(*clustering, c='orange', lw=1, label='Average clustering coefficient')
plt.legend(loc='best')

ax = plt.gca()
ax2 = ax.twinx()
ax2.plot(*mean_degree)
plt.ylabel('Mean degree (blue)')

plt.show()


I am working on the file "Case Study - Hunt a Serial Killer.ipynb".
The first task is:
Agency Type
What kind of agencies contribute to the unsolved homicide statistics?
Can you write Python code for it?

unsolved["Agency Type"].value_counts().plot(kind="bar")
#plt.yscale('log', nonposy='clip')


I am working on the file "Case Study - Hunt a Serial Killer.ipynb".
The first task is:
Can the scale we deploy for graphics, affect our perception of the nature of the data? Let's check different configurations.
Can you write Python code for it?

plt.rcParams["figure.figsize"] = (20,4)
df["Weapon"].value_counts().plot(kind = "bar")
plt.title('Deaths Attributable to Various Weapons')

plt.rcParams["figure.figsize"] = (10,10)
df["Weapon"].value_counts().plot(kind = "bar")
plt.title('Deaths Attributable to Various Weapons')

plt.rcParams["figure.figsize"] = (20,4)
plt.yscale('log', nonposy='clip')
df["Weapon"].value_counts().plot(kind = "bar")
plt.title('Deaths Attributable to Various Weapons')


I am working on the file "Case Study - Hunt a Serial Killer.ipynb".
The first task is:
Exploring Relationship Between Victims and Perpetrators
Can you write Python code for it?

df["Relationship"].unique()

known = df[df["Relationship"] != "Unknown"]
known.head()

known["Relationship"].value_counts()

plt.rcParams["figure.figsize"] = (20,5)
known["Relationship"].value_counts().plot(kind="bar")
plt.title("Relationsip of Victim to Perpetrator")
plt.yscale('log', nonposy='clip')


I am working on the file "Case Study - Hunt a Serial Killer.ipynb".
The first task is:
Import the CSV file
Can you write Python code for it?

# Note: You will have to unzip the file, as Github has a file size limit of 100mb
df = pd.read_csv("Data/database.csv")


I am working on the file "Case Study - Hunt a Serial Killer.ipynb".
The first task is:
Our dataset seems really clean, without any missing values, which is wonderful!
Can you write Python code for it?


I am working on the file "Case Study - Hunt a Serial Killer.ipynb".
The first task is:
Race
Is there a racial angle to these homicides?
Can you write Python code for it?

df.head(2)

df["Perpetrator Race"].unique()

df.columns

pd.pivot_table(known,index=["Victim Race","Perpetrator Race"],values=["Victim Count"],aggfunc=[np.sum])
               #columns=["Product"],aggfunc=[np.sum])


I am working on the file "Case Study - Hunt a Serial Killer.ipynb".
The first task is:
Unsolved Crimes
Let's pay some attention to unsolved crimes. What are their characteristics?
Can you write Python code for it?

df[df["Crime Solved"] != "Yes"].shape

unsolved = df[df["Crime Solved"] != "Yes"]

unsolved.head()

unsolved.describe()

plt.rcParams["figure.figsize"] = (20,7)
unsolved['Year'].value_counts().sort_index(ascending=True).plot(kind='line')
plt.title('Number of Unsolved Homicides: 1980 to 2014')

dict_states = {'Alaska':'AK','Alabama':'AL','Arkansas':'AR','Arizona':'AZ', 'California':'CA', 'Colorado':'CO', 'Connecticut':'CT',
'District of Columbia':'DC', 'Delaware':'DE', 'Florida':'FL', 'Georgia':'GA', 'Hawaii':'HI', 'Iowa':'IA',
'Idaho':'ID', 'Illinois':'IL', 'Indiana':'IN', 'Kansas':'KS', 'Kentucky':'KY', 'Louisiana':'LA',
'Massachusetts':'MA', 'Maryland':'MD', 'Maine':'ME', 'Michigan':'MI', 'Minnesota':'MN', 'Missouri':'MO',
'Mississippi':'MS', 'Montana':'MT', 'North Carolina':'NC', 'North Dakota':'ND', 'Nebraska':'NE',
'New Hampshire':'NH', 'New Jersey':'NJ', 'New Mexico':'NM', 'Nevada':'NV', 'New York':'NY', 'Ohio':'OH',
'Oklahoma':'OK', 'Oregon':'OR', 'Pennsylvania':'PA', 'Puerto Rico':'PR', 'Rhode Island':'RI',
'South Carolina':'SC', 'South Dakota':'SD', 'Tennessee':'TN', 'Texas':'TX', 'Utah':'UT',
'Virginia':'VA', 'Vermont':'VT', 'Washington':'WA', 'Wisconsin':'WI', 'West Virginia':'WV', 'Wyoming':'WY'}

abb_st = [val for val in dict_states.values()]
len(abb_st)

plt.rcParams["figure.figsize"] = (20,7)
ax = sns.countplot(x="State", hue="Weapon", data=unsolved[unsolved["Weapon"]=="Handgun"])
ax.set_xticklabels(abb_st)
plt.title("Unsolved Homicides Caused By Handguns")

unsolved['Weapon'].value_counts()

plt.rcParams["figure.figsize"] = (15,10)

unsolved['Weapon'].value_counts().plot(kind='bar')

bar = vincent.Bar(unsolved['State'].value_counts())
bar
bar.x_axis_properties(label_angle = 180+90, label_align = "right")
bar.legend(title = "Unsolved Homicides: Weapons Involved")

# Team_Before = df['Punches Before'].groupby(df['Team'])
rel = unsolved['Weapon'].groupby(unsolved['Victim Sex'])

rel.size().plot(kind='bar')


I am working on the file "Case Study - MovieLens.ipynb".
The first task is:
Let's look at how these movies are viewed across different age groups. First, let's look at how age is distributed amongst our users.
Can you write Python code for it?

users.age.hist(bins=30)
plt.title("Distribution of users' ages")
plt.ylabel('count of users')
plt.xlabel('age');

labels = ['0-9', '10-19', '20-29', '30-39', '40-49', '50-59', '60-69', '70-79']
bins = range(0, 81, 10) # [0, 10, 20, 30, 40, 50, 60, 70, 80]
lens['age_group'] = pd.cut(lens.age, bins, right=False, labels=labels)
print lens[['age', 'age_group']].drop_duplicates()[:5] # preview of age bin


I am working on the file "Case Study - MovieLens.ipynb".
The first task is:
Let's sort the resulting DataFrame so that we can see which movies have the highest average score.

Because movie_stats is a DataFrame, we use the sort method (only Series objects use order).

Additionally, because our columns are now a MultiIndex, we need to pass in a tuple specifying how to sort.
Can you write Python code for it?

print movie_stats.sort([('rating', 'mean')], ascending=False).head()


I am working on the file "Case Study - MovieLens.ipynb".
The first task is:
Summary

What are the 10 most rated movies ?
Which movies are most controversial amongst different age ?
Can you write Python code for it?

print movies.head(3), '\n'
print ratings.head(3), '\n'
print users.head(3)

print lens.head()

lens.describe()


I am working on the file "Case Study - MovieLens.ipynb".
The first task is:
The above movies are rated so rarely that we can't count them as quality films. Let's only look at movies that have been rated at least 100 times.
Can you write Python code for it?

atleast_100 = movie_stats['rating']['size'] > 100
print movie_stats[atleast_100].sort([('rating', 'mean')], ascending=False).head()


I am working on the file "Case Study - MovieLens.ipynb".
The first task is:
What are the 10 most rated movies ?

Split the DataFrame into groups by movie title
Apply the size method to get the count of records in each group
Order our results in descending order
Limit the output to the top 10 using Python's slicing syntax.

using .groupby()
Can you write Python code for it?

most_rated = lens.groupby('title').size().order(ascending=False)[:10]
print most_rated


I am working on the file "Case Study - MovieLens.ipynb".
The first task is:
Young users seem a bit more critical than other age groups. Let's look at how the 50 most rated movies are viewed across each age group. We can use the most_50 Series we created earlier for filtering.
Can you write Python code for it?

lens.set_index('movie_id', inplace=True)

by_age = lens.ix[most_50.index].groupby(['title', 'age_group'])
by_age.rating.mean().head(15)


I am working on the file "Case Study - Product Survey Analysis/Case Study Analysis.ipynb".
The first task is:
1) List the top 10 customers who had the maximum usage of all products
Can you write Python code for it?

# Perform a Group-By operation on "User_ID" and sum up the "Total_Amount" field
top10_users_products = df.groupby(['User_ID'], as_index=False)['Total_Amount'].sum()

# Sort in descending order based on "Total_Amount" field
top10_users_products.sort_values("Total_Amount", ascending=False, inplace=True)

# By default, pandas retains the index values as in the original dataframe.
# Reset the index to start from beginning
top10_users_products.reset_index(inplace=True)

# Show only the top 10 records
print top10_users_products.head(10)


I am working on the file "Case Study - Product Survey Analysis/Case Study Analysis.ipynb".
The first task is:
3) Which product has the maximum usage across all customers?
Can you write Python code for it?

product_max_usage = df.groupby(["Product"], as_index=False)["Total_Amount"].sum()
print product_max_usage.max(column="Total_Amount")


I am working on the file "Case Study - Product Survey Analysis/Case Study Analysis.ipynb".
The first task is:
4) Find the weekly usage of each product across all users
Can you write Python code for it?

# Survey duration is given as 90 days
SURVEY_DURATION = 90

# Take the current time
today_date = datetime.datetime.today()

# Calculate the start date as 90 days prior
start_date = today_date - datetime.timedelta(days=SURVEY_DURATION)

# Convert the date that is a string to YY-MM-DD format and
# find the number of days elapsed from the start date
df["Days"] = (df["Entry_Date"].apply(lambda x: datetime.datetime.strptime(x, "%Y-%m-%d")) - start_date) / np.timedelta64(1, "D")

# Round off the day values to a whole number
df["Days"] = df["Days"].round(0)

# Calculate the week by dividing the number of days by 7.
# Add 1 to start the week count from 1 instead of 0
df["Week"] = ((df["Days"] / 7) + 1).round()

# Remove the "Days" column
df.drop(["Days"], axis=1, inplace=True)

# Group by "Product" and "Week" fields followed by summation over "Total_Amount" field
weekly_usage_all_products = df.groupby(["Product", "Week"], as_index=False)["Total_Amount"].sum()

# Sort by "Week" and then "Product"
weekly_usage_all_products.sort_values(["Week", "Product"], inplace=True)

print weekly_usage_all_products

# Plotting the above data using seaborn package
print sb.factorplot(
    x="Week", y="Total_Amount",
    hue="Product",
    data=weekly_usage_all_products,
    size=12,
    kind="bar",
    palette="muted"
)


I am working on the file "CaseStudies/TheBARTModelofRiskTaking.ipynb".
The first task is:
16.2 A hierarchical extension of the BART model
$$ \mu_{\gamma^{+}} \sim \text{Uniform}(0,10) $$
$$ \sigma_{\gamma^{+}} \sim \text{Uniform}(0,10) $$
$$ \mu_{\beta} \sim \text{Uniform}(0,10) $$
$$ \sigma_{\beta} \sim \text{Uniform}(0,10) $$
$$ \gamma^{+}i \sim \text{Gaussian}(\mu{\gamma^{+}}, 1/\sigma_{\gamma^{+}}^2) $$
$$ \beta_i \sim \text{Gaussian}(\mu_{\beta}, 1/\sigma_{\beta}^2) $$
$$ \omega_i = -\gamma^{+}i \,/\,\text{log}(1-p) $$
$$ \theta{ijk} = \frac{1} {1+e^{\beta_i(k-\omega_i)}} $$
$$ d_{ijk} \sim \text{Bernoulli}(\theta_{ijk}) $$
Can you write Python code for it?

p = .15  # (Belief of) bursting probability
ntrials = 90   # Number of trials for the BART
Ncond = 3

dall = np.full([Ncond,ntrials,30], np.nan)
options = np.zeros((Ncond,ntrials))
kall = np.full([Ncond,ntrials,30], np.nan)
npumps_ = np.zeros((Ncond,ntrials))

for icondi in range(Ncond):
    if icondi == 0:
        Data = pd.read_csv('data/GeorgeSober.txt',sep='\t')
    elif icondi == 1:
        Data = pd.read_csv('data/GeorgeTipsy.txt',sep='\t')
    elif icondi == 2:
        Data = pd.read_csv('data/GeorgeDrunk.txt',sep='\t')
    # Data.head()
    cash = np.asarray(Data['cash']!=0, dtype=int)
    npumps = np.asarray(Data['pumps'], dtype=int)
    npumps_[icondi,:] = npumps
    options[icondi,:] = cash + npumps
    # response vector
    for j, ipumps in enumerate(npumps):
        inds = np.arange(options[icondi,j],dtype=int)
        kall[icondi,j,inds] = inds+1
        if ipumps > 0:
            dall[icondi,j,0:ipumps] = 0
        if cash[j] == 1:
            dall[icondi,j,ipumps] = 1

indexmask = np.isfinite(dall)
dij = dall[indexmask]
kij = kall[indexmask]
condall = np.tile(np.arange(Ncond,dtype=int),(30,ntrials,1))
condall = np.swapaxes(condall,0,2)
cij = condall[indexmask]

with pm.Model() as model2:
    mu_g = pm.Uniform('mu_g', lower=0, upper=10)
    sigma_g = pm.Uniform('sigma_g', lower=0, upper=10)
    mu_b = pm.Uniform('mu_b', lower=0, upper=10)
    sigma_b = pm.Uniform('sigma_b', lower=0, upper=10)

    gammap = pm.Normal('gammap', mu=mu_g, sd=sigma_g, shape=Ncond)
    beta = pm.Normal('beta', mu=mu_b, sd=sigma_b, shape=Ncond)

    omega = -gammap[cij]/np.log(1-p)
    thetajk = 1 - pm.math.invlogit(- beta[cij] * (kij - omega))

    djk = pm.Bernoulli("djk", p=thetajk, observed=dij)

    approx = pm.fit(n=100000, method='advi',
                    obj_optimizer=pm.adagrad_window
                    )  # type: pm.MeanField
    start = approx.sample(draws=2, include_transformed=True)
    trace2 = pm.sample(3e3, njobs=2, init='adapt_diag', start=list(start))
   ...


I am working on the file "CaseStudies/TheBARTModelofRiskTaking.ipynb".
The first task is:
Chapter 16 - The BART model of risk taking
16.1 The BART model
Balloon Analogue Risk Task (BART: Lejuez et al., 2002): Every trial in this task starts by showing a balloon representing a small monetary value. The subject can then either transfer the money to a virtual bank account, or choose to pump, which adds a small amount of air to the balloon, and increases its value. There is some probability, however, that pumping the balloon will cause it to burst, causing all the money to be lost. A trial finishes when either the subject has transferred the money, or the balloon has burst.
$$ \gamma^{+} \sim \text{Uniform}(0,10) $$
$$ \beta \sim \text{Uniform}(0,10) $$
$$ \omega = -\gamma^{+} \,/\,\text{log}(1-p) $$
$$ \theta_{jk} = \frac{1} {1+e^{\beta(k-\omega)}} $$
$$ d_{jk} \sim \text{Bernoulli}(\theta_{jk}) $$
Can you write Python code for it?

p = .15  # (Belief of) bursting probability
ntrials = 90   # Number of trials for the BART

Data = pd.read_csv('data/GeorgeSober.txt', sep='\t')
# Data.head()
cash = np.asarray(Data['cash']!=0, dtype=int)
npumps = np.asarray(Data['pumps'], dtype=int)

options = cash + npumps

d = np.full([ntrials,30], np.nan)
k = np.full([ntrials,30], np.nan)
# response vector
for j, ipumps in enumerate(npumps):
    inds = np.arange(options[j],dtype=int)
    k[j,inds] = inds+1
    if ipumps > 0:
        d[j,0:ipumps] = 0
    if cash[j] == 1:
        d[j,ipumps] = 1

indexmask = np.isfinite(d)
d = d[indexmask]
k = k[indexmask]

with pm.Model():
    gammap = pm.Uniform('gammap', lower=0, upper=10, testval=1.2)
    beta = pm.Uniform('beta', lower=0, upper=10, testval=.5)
    omega = pm.Deterministic('omega', -gammap/np.log(1-p))

    thetajk = 1 - pm.math.invlogit(- beta * (k - omega))

    djk = pm.Bernoulli('djk', p=thetajk, observed=d)

    trace = pm.sample(3e3, njobs=2)

pm.traceplot(trace, varnames=['gammap', 'beta']);

from scipy.stats.kde import gaussian_kde
burnin=2000
gammaplus = trace['gammap'][burnin:]
beta = trace['beta'][burnin:]

fig = plt.figure(figsize=(15, 5))
gs = gridspec.GridSpec(1, 3)

ax0 = plt.subplot(gs[0])
ax0.hist(npumps, bins=range(1, 9), rwidth=.8, align='left')
plt.xlabel('Number of Pumps', fontsize=12)
plt.ylabel('Frequency', fontsize=12)

ax1 = plt.subplot(gs[1])
my_pdf1 = gaussian_kde(gammaplus)
x1=np.linspace(.5, 1, 200)
ax1.plot(x1, my_pdf1(x1), 'k', lw=2.5, alpha=0.6) # distribution function
plt.xlim((.5, 1))
plt.xlabel(r'$\gamma^+$', fontsize=15)
plt.ylabel('Posterior Density', fontsize=12)

ax2 = plt.subplot(gs[2])
my_pdf2 = gaussian_kde(beta)
x2=np.linspace(0.3, 1.3, 200)
ax2.plot(x2, my_pdf2(x2), 'k', lw=2.5, alpha=0.6,) # distribution function
plt.xlim((0.3, 1.3))
plt.xlabel(r'$\beta$', fontsize=15)
plt.ylabel('Posterior Density', fontsize=12);


I am working on the file "Catedras/Catedra_01-02.ipynb".
The first task is:
Catedra 02 (Continuacion de Catedra 01)
Integrales Numericas
$$g(x) = \int_{a}^{x} f(x')dx'$$
Equivale a resolver una ecuacion diferencial:
$$g'(x)  = f(x)$$ con condiciones de borde:
$$\int_{a}^{x}g'(x')dx' = \int_{a}^{x}f(x')dx'$$
$$g(x)-g(a) = \int_{a}^{x}f(x')dx'$$
Integracion Numerica Directa
Regla Trapezoidal
Idea: Aproximar el area de la curva como el area bajo un trapecio entre dos puntos de la funcion

$$
\int_{x_{0}}^{x_{0}+\Delta x}f(x')dx'
$$
Haciendo una expansion de taylor sobre la integral se obtiene:
$$
\int_{x_{0}}^{x_{0}+\Delta x}\left[
    f(x_{0}) + f'(x_{o})(x'-x_{0}) + \frac{1}{2}f''(x_{0})(x'-x_{0})^{2} + \ldots
\right]dx'
$$
$$
= f(x_{0}\Delta x) + \frac{f'(x_{0})(x-x_{0})^{2}}{2}\biggr\vert_{x_{0}}^{x} + \frac{1}{2}f''(x_{0})\frac{(x-x_{0})^{3}}{3}\biggr\vert_{x_{0}}^{x} + \ldots
$$
$$
= f(x_{0})\Delta x + f'(x_{0})\frac{\Delta x^{2}}{2} + \frac{1}{6}f''(x_{0})\Delta x^{3} + \ldots
$$
$$
= \frac{\Delta x}{2}\left[
    f(x_{0}) + \left(
        f(x_{0}) + f'(x_{0})\Delta x + f''(x_{0})\frac{\Delta x^{2}}{2} + \ldots
    \right) - f''(x_{0})\frac{\Delta x^{2}}{6}
\right]
$$
Note que el error de truncacion es del mismo orden en $\Delta x$ que el ultimo termino previo a truncar.
$$
\int_{x_0}^{x_{0}+\Delta x}f(x')dx' = \frac{\Delta x}{2}\left[
    f(x_{0}) + f(x_{0}+\Delta x) + O(\Delta x^2)
\right] = \left(
    f(x_{0}) + f(x_{0}+\Delta x)
\right)\frac{\Delta x}{2} + O(\Delta x^3)
$$
Donde $O(\Delta x^3) \sim -f''(x_{0})\frac{\Delta x^3}{12}$
(graficos van aca)
dividir [a,b] en $N = \frac{b-a}{\Delta x}$ tramos.
$$
\int_{a}^{b}f(x)dx \sim \sum_{i=0}^{N-1}\left[
    \frac{f(a+\Delta xi)+f(a+\Delta x(i+1))}{2}\Delta x + O^{*}(\Delta x^3)
\right]
$$
Nos interesa encontrar una cota superior para nuestro error. Como estamos sumando N tramos, estamos incluyendo N errores, y dado que el error de cada tramo va como $\Delta x^3$ y N va como $\Delta x$, el error finalmente queda como $O(\Delta x^2)$
$$
\sim \left[
    \sum_{i=0}^{N-1}\frac{f(a+\Delta xi)+f(a+\Delta x(i+1))}{2}\Delta x
\right] +...
Can you write Python code for it?

def integral_trap(f, intervalo):
    '''
    Integracion numerica utilizando el metodo o regla trapezoidal.
    Note que el intervalo debe estar equiespaciado para este metodo.

    Parameters
    ----------
    f : numpy.ndarray
        Integrando.
    intervalo : numpy.ndarray
        El intervalo de integracion.

    Returns
    -------
    res : double
        Resultado de la integracion.
    '''
    res = f[0]+f[len(intervalo-1)] # Se inicializa la variable que contendra el resultado final.
    dx = intervalo[1] - intervalo[0] # Se escribe el delta x.
    for i in range(len(intervalo)-1): # Se escribe el ciclo que calculara la integral numericamente.
        res += 2*(f[i]+f[i+1])

    res *= dx/2.

    return res


I am working on the file "Catedras/Catedra_01-02.ipynb".
The first task is:
Efectos de precision sobre integrales
Error de Redondeo
Calculando la derivada de $\sin(x)$
Ahora usamos numpy
Can you write Python code for it?

import numpy as np

epsilon = np.logspace(-1, -15, 14, base=10.)
print(epsilon)

print(type(e_vs_n))
print(type(epsilon))

dsindx = (np.sin(1.+epsilon) - np.sin(1.)) / epsilon
print(dsindx)

plt.semilogx(epsilon, dsindx - np.cos(1.), 'o')
plt.axhline(0, color='0.8')
plt.xlabel('epsilon', fontsize=20)
plt.ylabel('$\\frac{d}{dx}\\sin(x) - \\cos(x)$', fontsize=20)
_ = plt.xticks(epsilon[::2])


I am working on the file "Catedras/Catedra_01-02.ipynb".
The first task is:
Manejo de errores:
Error de truncacion

Calculo del numero e a traves de la expansion de Taylor: $\sum_{k=0}^{\infty}\frac{x^{k}}{k!}$

Forma basica:
Can you write Python code for it?

# Parametros iniciales.
e = 1.
k_factorial = 1.
N_max = 10
e_vs_n = [e] # Lista que va a contener los elementos de la serie.
for i in range(1,N_max): # Ciclo que calcula los elementos de la serie y los suma.
    k_factorial *= i
    e += 1. / k_factorial
    e_vs_n.append(e)

# Instruccion para imprimir nuestra aproximacion a e en cada iteracion.
for i in range(N_max):
    print(i, e_vs_n[i])

plt.plot(range(N_max), e_vs_n) # Genera un grafico de e_vs_n v
plt.axhline(math.e, color='0.5') # Genera una linea en 'e'
plt.ylim(0,3) # Cambia los limites del eje y del grafico
# Cambia los labels del grafico.
plt.xlabel('N', fontsize=20)
plt.ylabel('$e_{N}$', fontsize=20)

# Se hace un ciclo for dentro de una lista. i.e. Comprehension list
diferencia = [math.fabs(e_i - math.e) for e_i in e_vs_n] # Nota. fabs convierte a float y luego calcular abs
# Se hace un grafico con escala logaritmica en el eje y.
plt.plot(range(N_max), diferencia)
plt.yscale('log')
plt.xlabel('N', fontsize=20)
plt.ylabel('$e_N - e_{real}$', fontsize=20)

"""
NOTA:
Lo anterior es equivalente a hacer
plt.semilogy(range(N_max), diferencia))
plt.xlabel('N', fontsize=20)
plt.ylabel('$e_N - e_{real}$', fontsize=20)
"""


I am working on the file "Catmull-Rom-splines.ipynb".
The first task is:
Catmull-Rom interpolating curves can be evaluated
at a point using a recursive scheme similar to the de Boor algorithm for B-spline curves.
Usually a cubic spline curve is $C^2$ at knots. Although the CR curves are only $C^1$ at each knot,
they are sometimes called Catmull Rom spline curves, due to the similarities of the algorithms of
evaluation, and other common properties.
Let us point out the drawback of the uniform parameterization, that led to defining CR splines with
non-uniform knots.
A $C^1$-parameterization,  $c:[a,b]\to\mathbb{R}^d$, of a curve can be interpreted as defining the motion of the point c(t), along the trace of $c$,  during the time from a to b.
When the parameterization of a CR curve is uniform, the point $c(t)$ spends the same amount of time on each arc of ends $P_i, P_{i+1}$, $i=1,2, ...n-1$, irrespective of the distance between $P_i, P_{i+1}$.
If the distance between two data points is large, the point c(t)
moves with a high speed. If the next two interpolatory points, $P_{i+1}, P_{i+2}$, are closer, then the moving point will overshoot since it cannot abruptly change its  speed.
Barry and Goldman [P. J. Barry, R. N. Goldman, A recursive evaluation algorithm for a class of Catmull–Rom splines, SIGGRAPH Computer Graphics, 22(4):199-204, 1988] extended the definition of uniform parameterized CR splines to curves whose parameterization incorporates the
distance between any two adjacent interpolatory points.
Namely, given the points $P_0, P_1, \ldots, P_n$, one defines a knot sequence, $t_0, t_1, \ldots, t_{n}$ as follows:
$$\begin{array}{lll}t_0&=&0\
            t_i&=&t_{i-1}+||\overrightarrow{P_{i-1}P_i}||^\alpha, \quad \alpha\in[0,1]\end{array}$$
A $C^1$-piecewise cubic, that interpolates the given points, i.e. $c(t_i)=P_i$, $i=1,2, \ldots, n-1$, is defined at any $u\in[t_i, t_{i+1}]$ through a recursive scheme in which are involved only four points, $P_{i-1}, P_i, P_{i+1}, P_{i+2}$
 and the knots $t_{i-1}, t_i, t_{i+1},...
Can you write Python code for it?

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline


I am working on the file "Catmull-Rom-splines.ipynb".
The first task is:
Now we give a list of points and define the CR curve corresponding to $\alpha=0,0.5,1$:
Can you write Python code for it?

P=[[-0.72, -0.3], [0,0], [1., 0.8], [1.1, 0.5], [2.7, 1.2], [3.4, 0.27]]

curve0=Catmull_Rom(P, alpha=0, closed=False)
curve1=Catmull_Rom(P, alpha=0.5, closed=False)
curve2=Catmull_Rom(P, alpha=1.0, closed=False)
xp, yp=zip(*P)

fig=plt.figure(figsize=(9,6))
plt.plot(curve0[:,0], curve0[:,1], 'r', xp, yp, 'go' )
plt.plot(curve1[:,0], curve1[:,1], 'g')
plt.plot(curve2[:,0], curve2[:,1], 'b')


I am working on the file "Catmull-Rom-splines.ipynb".
The first task is:
The above functions are independent on the dimension of the space of points. They work well on points in  any space $\mathbb{R}^d$, $d\geq 2$.
Here is an illustration of a Plotly plot of a (2,3)-torus knot resulted from a centripetal Catmull-Rom interpolation of a set of points on torus:
Can you write Python code for it?

from IPython.display import HTML
HTML('<iframe src=https://plot.ly/~empet/13914/ width=900 height=600></iframe>')

from IPython.core.display import HTML
def  css_styling():
    styles = open("./custom.css", "r").read()
    return HTML(styles)
css_styling()


I am working on the file "Catmull-Rom-splines.ipynb".
The first task is:
The green curve is the centripetal CR spline interpolating the central 4 from 6  points. It folows closely
the given interpolatory points.
In order to get more insights into  CR curves properties we give the possibility to generate them interactively.
Choose the interpolatory points, by clicking the left mouse button at the desired position. When the   right button is pressed, the corresponding curve is generated:
Can you write Python code for it?

#enable interactivity in notebook:
%matplotlib notebook

def curve_plot(i_pts,  alpha=0.5, closed=False):
    curve_pts=Catmull_Rom(i_pts, alpha, closed=closed)
    # plot the interpolating curve
    plt.plot(curve_pts[:,0], curve_pts[:,1], 'b')

class catrom(object):

    def __init__(self,  alpha=0.5, closed=False):
        self.interp_pts=[]     # list of interpolating points
        self.alpha=alpha
        self.closed=closed# boolean value
    def callback(self, event):  #select interpolating points with  left  mouse button click
        if event.button==1 and event.inaxes:
            x,y = event.xdata, event.ydata
            self.interp_pts.append([x,y])
            plt.plot(x, y,  'bo')

        elif event.button==3:   #press right  button to plot the curve
            curve_plot(self.interp_pts,  self.alpha, self.closed)
            plt.draw()

        else: pass

    def caxis(self):#define axes for plot
        fig = plt.figure(figsize=(8, 6))
        ax = fig.add_subplot(111)

        ax.set_xlim(0,10)
        ax.set_ylim(0,10)
        ax.grid('on')
        ax.set_autoscale_on(False)
        fig.canvas.mpl_connect('button_press_event', self.callback)

curve=catrom()
curve.caxis()

cv=catrom(closed=True)
cv.caxis()

cv2=catrom(alpha=0)
cv2.caxis()


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Ajustement fin du réseau VGG16
Dans la partie précédente, nous avons configurer un bloc de réseaux de neurones, à même de prendre en entrée les features issues des transformation des 5 premiers blocs de convolution du modèle VGG16.
Dans cette partie, nous allons 'brancher' ce bloc directement sur les cinq premiers blocs du modèle VGG16 pour pouvoir affiner le modèle en itérant a la fois sur les blocs de convolution mais également sur notre bloc de réseau de neurone.

Création du modèle
On télécharge dans un premier temps le modèle VGG16, comme précédement.
Cependant, le modèle va cette fois être "entrainé" directement. Il ne va pas servir qu'a générer des features. Il faut donc préciser en paramètre la taille des images que l'on va lui donner.
Can you write Python code for it?

# build the VGG16 network
model_VGG16_without_top = ka.VGG16(include_top=False, weights='imagenet', input_shape=(150,150,3))
print('Model loaded.')


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Apprentissage
Can you write Python code for it?

model_VGG_LastConv_fcm.compile(loss='binary_crossentropy',
              optimizer=ko.SGD(lr=1e-4, momentum=0.9),
              metrics=['accuracy'])

# fine-tune the model
ts = time.time()
model_VGG_LastConv_fcm.fit_generator(
    train_generator,
    steps_per_epoch=N_train // batch_size,
    epochs=epochs,
    validation_data=validation_generator,
    validation_steps=N_val // batch_size)
te = time.time()
t_learning_VGG_LastConv_fcm = te-ts


# On créer des vecteurs labels

train_labels = np.array([0] * int((N_train/2)) + [1] * int((N_train/2)))
validation_labels = np.array([0] * int((N_val/2)) + [1] * int((N_val/2)))

model_VGG_fcm.fit(features_train, train_labels,
          epochs=epochs,
          batch_size=batch_size,
          validation_data=(features_validation, validation_labels))
t_learning_VGG_fcm = te-ts


ts = time.time()
model_conv.fit_generator(train_generator, steps_per_epoch=N_train // batch_size, epochs=epochs,
       validation_data=validation_generator,validation_steps=N_val // batch_size)
te = time.time()
t_learning_conv_simple_model = te-ts
print("Learning TIme for %d epochs : %d seconds"%(epochs,t_learning_conv_simple_model))
model_conv.save(data_dir_sub+'/'+MODE+'_models_convolutional_network_%d_epochs_%d_batch_size.h5' %(epochs, batch_size))


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Autres modèles
Keras possède un certain nombre d'autres modèles pré-entrainés:

Xception
VGG16
VGG19
ResNet50
InceptionV3
InceptionResNetV2
MobileNet

Certains possèdent une structure bien plus complexe, notamment InceptionV3. Vous pouvez très facilement remplacer la fonction ka.VGG16 par une autre fonction (ex : ka.InceptionV3) pour tester la performance des ces différents modèles et leur complexité.
Exercice Vous pouvez re-effectuer les manipulations précédentes sur d'autres modèle pré-entrainé, en prenant le temps d'étudiez leur architecture.
Exercice Vous pouvez également re-effectuer ces apprentissage sur un jeu de données plus gros en en créant un nouveau à partir des données originales.
L'application de ces exercices sur les données du challenge est vivement conseillées :)
Prédiction sur le jeu test de Kaggle
Voyons à présent comment notre réseau performe sur un échantillon du dataset test de keras.
Can you write Python code for it?

data_dir_test = data_dir+'test/'
N_test = len(os.listdir(data_dir_test+"/test"))

test_datagen = kpi.ImageDataGenerator(rescale=1. / 255)

test_generator = test_datagen.flow_from_directory(
    data_dir_test,
    #data_dir_sub+"/train/",
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode=None,
    shuffle=False)

test_prediction = model_VGG_LastConv_fcm.predict_generator(test_generator, N_test // batch_size)

images_test = [data_dir_test+"/test/"+k for k in os.listdir(data_dir_test+"/test")][:9]
x_test  = [kpi.img_to_array(kpi.load_img(image_test))/255 for image_test in images_test]  # this is a PIL image

fig = plt.figure(figsize=(10,10))
for k in range(9):
    ax = fig.add_subplot(3,3,k+1)
    ax.imshow(x_test[k], interpolation='nearest')
    pred = test_prediction[k]
    if pred >0.5:
        title = "Probabiliy for dog : %.1f" %(pred*100)
    else:
        title = "Probabiliy for cat : %.1f" %((1-pred)*100)
    ax.set_title(title)
plt.show()


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Classification d'image à l'aide du Deep Learning
Dans un premier temps, nous allons fixer le nombre d'epochs ainsi que la taille de notre batch afin que ces deux paramètres soit communs aux différentes méthodes que nous allons tester.
Queques règles à suivre pour le choix de ces paramètres :

epochs: Commencer avec un nombre d'epochs relativement faible (2,3) afin de voir le temps de calcul nécessaire à votre machine, puis augmenter le en conséquence.
batch_size: La taille du batch correspond au nombre d'éléments qui seront étudié a chaque itération au cours d'une epochs.

Important : Avec Keras, lorsque les données sont générés avec un générateur (voir précédemment) la taille du batch doit être un diviseur de la taille de l'échantillon. Sinon l'algorithme aura des comportement anormaux qui ne généreront pas forcément un message d'erreur.
Can you write Python code for it?


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Construction d'un réseaux de neurone classique.
On construit un réseaux de neurones "classique", identique à la seconde partie du réseau précédent.
Attention : La première couche de ce réseaux (Flatten) doit être configurée pour prendre en compte des données dans la dimension des features générées précédemment
Can you write Python code for it?

model_VGG_fcm = km.Sequential()
model_VGG_fcm.add(kl.Flatten(input_shape=features_train.shape[1:]))
model_VGG_fcm.add(kl.Dense(64, activation='relu'))
model_VGG_fcm.add(kl.Dropout(0.5))
model_VGG_fcm.add(kl.Dense(1, activation='sigmoid'))

model_VGG_fcm.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model_VGG_fcm.summary()


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Création des caractéristiques
On applique alors les 5 blocs du modèle VGG16 sur les images de nos échantillons d'apprentissage et de validation.
Cette opération peut-être couteuse, c'est pourquoi on va sauver ces features dans des fichiers afin d'effectuer qu'une fois cette opération.
Si ces fichiers existent, les poids seront téléchargés, sinon il seront créés.
Can you write Python code for it?

features_train_path = data_dir_sub+'/features_train.npy'
features_validation_path = data_dir_sub+'/features_validation.npy'

if os.path.isfile(features_train_path) and os.path.isfile(features_validation_path):
    print("Load Features")
    features_train = np.load(open(features_train_path, "rb"))
    features_validation = np.load(open(features_validation_path, "rb"))

else:
    print("Generate Features")
    datagen = kpi.ImageDataGenerator(rescale=1. / 255)

    generator = datagen.flow_from_directory(
            data_dir_sub+"/train",
            target_size=(img_width, img_height),
            batch_size=batch_size,
            class_mode=None,  # this means our generator will only yield batches of data, no labels
            shuffle=False)
    features_train = model_VGG16_without_top.predict_generator(generator, N_train / batch_size,  verbose = 1)
    # save the output as a Numpy array
    np.save(open(features_train_path, 'wb'), features_train)

    generator = datagen.flow_from_directory(
        data_dir_sub+"/validation",
            target_size=(img_width, img_height),
            batch_size=batch_size,
            class_mode=None,
            shuffle=False)
    features_validation = model_VGG16_without_top.predict_generator(generator, N_val / batch_size,  verbose = 1)
    # save the output as a Numpy array
    np.save(open(features_validation_path, 'wb'), features_validation)


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Définition du modèle
Le modèle est consitué de 3 blocs de convolution consitutés chacun de:

Une couche de Convolution2D
Une couche d'Activation ReLU
Une couche MaxPooling2D

Suivi de :
* Une couche Flatten, permettant de convertir les features de 2 à 1 dimensions.
* Une couche Dense (Fully connected layer)
* Une couche d' Activation ReLU
* Une couche Dropout
* Une couche Dense de taille 1 suivi d'une Activation sigmoid permettant la classification binaire
On utilise la fonction de perte binary_crossentropy pour apprendre notre modèle
Can you write Python code for it?

model_conv = km.Sequential()
model_conv.add(kl.Conv2D(32, (3, 3), input_shape=(img_width, img_height, 3), data_format="channels_last"))
model_conv.add(kl.Activation('relu'))
model_conv.add(kl.MaxPooling2D(pool_size=(2, 2)))

model_conv.add(kl.Conv2D(32, (3, 3)))
model_conv.add(kl.Activation('relu'))
model_conv.add(kl.MaxPooling2D(pool_size=(2, 2)))

model_conv.add(kl.Conv2D(64, (3, 3)))
model_conv.add(kl.Activation('relu'))
model_conv.add(kl.MaxPooling2D(pool_size=(2, 2)))

model_conv.add(kl.Flatten())  # this converts our 3D feature maps to 1D feature vectors
model_conv.add(kl.Dense(64))
model_conv.add(kl.Activation('relu'))
model_conv.add(kl.Dropout(0.5))
model_conv.add(kl.Dense(1))
model_conv.add(kl.Activation('sigmoid'))

model_conv.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

model_conv.summary()


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Generate Data
Can you write Python code for it?

# prepare data augmentation configuration
train_datagen = kpi.ImageDataGenerator(
    rescale=1. / 255,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True)

test_datagen = kpi.ImageDataGenerator(rescale=1. / 255)

train_generator = train_datagen.flow_from_directory(
    data_dir_sub+"/train/",
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
    data_dir_sub+"/validation/",
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='binary')


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Illustration des données
La fonction load_img permet de charger une image comme une image PIL.
Can you write Python code for it?

img = kpi.load_img(data_dir_sub+'/train/cats/cat.1.jpg')  # this is a PIL image
img


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
La commande .flow() genere de nouveaux exemples à partir de l'image originale et les sauve dans le dossier spécifié dans save_to_dir.
On force l'arrêt de cette génération après huits images générées.
Can you write Python code for it?

img_width = 150
img_height = 150

img = kpi.load_img(data_dir_sub+"/train/cats/cat.1.jpg")  # this is a PIL image
x = kpi.img_to_array(img)
x_ = x.reshape((1,) + x.shape)

if not(os.path.isdir(data_dir_sub+"/preprocessing_example")):
    os.mkdir(data_dir_sub+"/preprocessing_example")

    i = 0
    for batch in datagen.flow(x_, batch_size=1,save_to_dir=data_dir_sub+"/preprocessing_example", save_prefix='cat', save_format='jpeg'):
        i += 1
        if i > 7:
            break


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
La commande suivante permet de verifier qu'une carte GPU est bien disponible sur la machine utilisée. Si c'est le cas et si Keras a bien été installé dans la configuration GPU (c'est généralement le cas dans l'environement virtuel GPU d'Anaconda), deux options vont apparaitre, une CPU et une GPU. La configuration GPU sera alors automatiquement utilisée.
Can you write Python code for it?

from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())

MODE = "GPU" if "GPU" in [k.device_type for k in device_lib.list_local_devices()] else "CPU"
print(MODE)


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
La fonction img_to_array génére un array numpy a partir d'une image PIL .
Can you write Python code for it?

x = kpi.img_to_array(img)
plt.imshow(x/255, interpolation='nearest')
plt.show()


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Or les images doivent être de même dimensions pour être utilisée dans un même réseau.
La fonction ImageDataGeneratorde Keras permet de remédier à ce problème.
Plus généralement cette fonction applique un certain nombre de traitements (transformation, normalisation) aléatoires sur les images de sorte que le modèle n'apprenne jamais deux fois la même image.
Quelques arguments de cette fonction:
* rotation_range: Un interval représentant les degrés possibles de rotation de l'image,
* width_shift and height_shift: intervales au sein desquels les données peuvent être translatées horizontalement ou verticalement,
* rescale:  Une valeur par lequelle les données sont multipliées,
* shear_range:  Transvection,
* zoom_range: Permet des zoom au sein d'une image,
* horizontal_flip: Inverse aléatoirement des images selon l'axe horizontal,
* fill_mode: La strategie adoptée pour combler les pixels manquants après une transformation.
Can you write Python code for it?

datagen = kpi.ImageDataGenerator(
        rotation_range=40,
        width_shift_range=0.2,
        height_shift_range=0.2,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True,
        fill_mode='nearest')


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Pré-traitements
Les images du jeu de données sont de dimensions différentes :
Can you write Python code for it?

x_0 = kpi.img_to_array(kpi.load_img(data_dir_sub+"/train/cats/cat.0.jpg"))
x_1 = kpi.img_to_array(kpi.load_img(data_dir_sub+"/train/cats/cat.1.jpg"))
x_0.shape, x_1.shape


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Prédiction
Can you write Python code for it?

ts = time.time()
score_VGG_fcm_val = model_VGG_fcm.evaluate(features_validation, validation_labels)
score_VGG_fcm_train = model_VGG_fcm.evaluate(features_train, train_labels)
te = time.time()
t_prediction_VGG_fcm = te-ts
print('Train accuracy:', score_VGG_fcm_train[1])
print('Validation accuracy:', score_VGG_fcm_val[1])
print("Time Prediction: %.2f seconds" %t_prediction_VGG_fcm)


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Q Commentez les performances de ce nouveau modèle
Nous allons également sauver les poids de ce modèle afin de les réusiliser dans la prochaine partie.
Can you write Python code for it?


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Q Commentez les valeurs de prédictions d'apprentissage et de validation. Comparez les avec les résultats de la dernière epochs d'apprentissage. Qu'observez vous? Est-ce normal?
Exercice Re-faites tournez ce modèle en ajoutant plus de transformation aléatoire dans le générateur d'image au moment de l'apprentissage. Que constatez-vous?
Réseau pré-entrainé : VGG16
Nous allons voir dans cette partie deux façon d'utiliser un modèle pré-entrainé:

Dans un premier temps on utilise le modèle pour extraire des features des images qui seront utilisés dans un réseaux de convolution "classique". Ces features sont le résultats des transformations des différents blocs de convolution sur nos images.
Dans un second temps on branchera le modèle "classique" généré  directement sur le modèle pré-entrainé. Ce modèle sera ensuite ré-entraîné plus finement (Fine Tuning) sur le dernier bloc de convolution.

Illustration du réseau

Extraction de nouvelle caractéristiques (features)
Téléchargement des poids du modèle
Si cest la première fois que vous appeler l'application VGG16, le lancement des poids commencera automatiquement et seront stocké dans votre home : "~/.keras/models"
On utilise le modèle avec l'option ìnclude_top = False. C'est à dire que l'on ne télécharge pas le dernier bloc Fully connected classifier.
La fonction summary permet de retrouver la structure décrite précédemment.
Can you write Python code for it?

model_VGG16_without_top = ka.VGG16(include_top=False, weights='imagenet')
model_VGG16_without_top.summary()


I am working on the file "CatsVSDogs/Atelier-keras-CatsVSDogs.ipynb".
The first task is:
Réseau convolutionnel
Dans un premiers temps, on construit notre propre réseau de neurones convolutionnel.
Génération des données
On définit deux objets ImageDataGenerator :

train_datagen: pour l'apprentissage, où différentes transformations sont appliquées, comme précédement
valid_datagen: pour la validation, où l'on applique seulement une transformation rescale pour ne pas déformer les données.

Il est également important de définir la taille des images dans laquelle nos images seront reformatées. Ici nous choisirons un taille d'image de 150x150
Can you write Python code for it?

# this is the augmentation configuration we will use for training
train_datagen = kpi.ImageDataGenerator(
        rescale=1./255,
)

# this is the augmentation configuration we will use for testing:
# only rescaling
valid_datagen = kpi.ImageDataGenerator(rescale=1./255)

# this is a generator that will read pictures found in
# subfolers of 'data/train', and indefinitely generate
# batches of augmented image data
train_generator = train_datagen.flow_from_directory(
        data_dir_sub+"/train/",  # this is the target directory
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='binary')  # since we use binary_crossentropy loss, we need binary labels

# this is a similar generator, for validation data
validation_generator = valid_datagen.flow_from_directory(
        data_dir_sub+"/validation/",
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='binary')


I am working on the file "Cavendish_Experiment/Scripts/20171010_cavendish_dayone_trial.ipynb".
The first task is:
The weird behavior at the beginning occured when we were making an alteration to the experimental setup itself (doing one of our many adjustments to try and zero out our $\theta_e$. We can ignore this as it is not indicative of our data and look at where it moves into a damped harmonic oscialltion.
Can you write Python code for it?

plt.plot(trial_data[3900:,0], trial_data[3900:,1])
plt.title("Trial Data from Cavendish Balance, Adjusted")
plt.ylabel("Anglular Positon (mrads)")
plt.xlabel("Time (s)")

np.savetxt(data_dir+'20171010_cavendish_trial_useable.txt', trial_data[3200:,], delimiter=',')

x_data = trial_data[3900:,0]
y_data = trial_data[3900:,1]

#I want to try to extract the peaks of the corresponding sine waves to show the exponential decay and use that
#to fit my curve to.

angles = []
time = []

for i in range(1, len(y_data)-1):
    if y_data[i] >= np.average(y_data):
        if (y_data[i] > y_data[i-1]) and (y_data[i] > y_data[i+1]):
            angles.append(float(y_data[i]))
            time.append(float(x_data[i]))

inds = argex(np.array(angles), np.greater)
times = np.array(time)[inds]
turning_points = np.array(angles)[inds]
plt.plot(times, turning_points, 'g--')
plt.plot(x_data, y_data, 'b-')


I am working on the file "Cavendish_Experiment/Scripts/20171010_cavendish_dayone_trial.ipynb".
The first task is:
Trying out the scipy.optimzie library to fit this to a decaying sinuisodal curve.
Can you write Python code for it?

from scipy.optimize import curve_fit

def decay(t, a, b, w, phi, theta_0):
    return a*np.exp(-b*t)*np.cos(w*t + phi) + theta_0

popt, pcov = curve_fit(decay, x_data, y_data , p0 = (-32, 1.3e-3, 3e-2, -6e-1, 0))

popt

plt.plot(times, turning_points, 'b--', label = 'Decay from Data')
plt.plot(x_data, y_data, 'r-', linewidth = 5, label = "Raw Data")
plt.plot(x_data, decay(x_data, *popt), 'g-', label = 'Fit of a*np.exp(-b*t)*np.cos(w*t + phi) + theta_0')
plt.title("Free Oscillation Data, No Large Masses")
plt.ylabel("Angle, Not Calibrated (mrad)")
plt.xlabel("Time (s)")
plt.legend()

round(popt[1],5)


I am working on the file "Cavendish_Experiment/Scripts/20171025_cavendish_new_wire_decay.ipynb".
The first task is:
$$b = 1.41 \times 10 ^{-3} \frac{1}{s}$$
Can you write Python code for it?


I am working on the file "Cavendish_Experiment/Scripts/20171025_cavendish_new_wire_decay.ipynb".
The first task is:
The weird behavior at the beginning occured when we were making an alteration to the experimental setup itself (doing one of our many adjustments to try and zero out our $\theta_e$. We can ignore this as it is not indicative of our data and look at where it moves into a damped harmonic oscialltion.
Can you write Python code for it?

x_data = trial_data[:,0]
y_data = trial_data[:,1]


I am working on the file "Cavendish_Experiment/Scripts/20171025_cavendish_new_wire_decay.ipynb".
The first task is:
Trying out the scipy.optimzie library to fit this to a decaying sinuisodal curve.
Can you write Python code for it?

from scipy.optimize import curve_fit

def decay(t, a, b, w, phi, theta_0):
    return a*np.exp(-b*t)*np.cos(w*t + phi) + theta_0

popt, pcov = curve_fit(decay, x_data, y_data , p0 = (50, 1.3e-3, 3e-2, -6e-1, 0))

popt

plt.plot(x_data, y_data, 'r-', linewidth = 0.3, label = "Raw Data")
# plt.plot(x_data, decay(x_data, *popt), 'g-', label = 'Fit of a*np.exp(-b*t)*np.cos(w*t + phi) + theta_0')
plt.title("Free Oscillation Data, No Large Masses")
plt.ylabel("Angle, Not Calibrated (mrad)")
plt.xlabel("Time (s)")
plt.legend()

plt.plot(x_data[:800], y_data[:800], 'rp', linewidth = 5, label = "Raw Data")
plt.plot(x_data[:800], decay(x_data[:800], *popt), 'g-', label = 'Fit of a*np.exp(-b*t)*np.cos(w*t + phi) + theta_0')
plt.title("Free Oscillation Data, No Large Masses")
plt.ylabel("Angle, Not Calibrated (mrad)")
plt.xlabel("Time (s)")
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)

round(popt[1],5)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Affiche les 5 premières lignes de la DataFrame d'apprentissage après nettoyage.
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Applique le nettoyage sur toutes les lignes de la DataFrame et créé deux nouvelles Dataframe (avant et sans l'étape de racinisation).
Can you write Python code for it?

# fonction de nettoyage du fichier(stemming et liste de mots à supprimer)
def clean_df(input_data, column_names= ['Description', 'Libelle', 'Marque']):

    nb_line = input_data.shape[0]
    print("Start Clean %d lines" %nb_line)

    # Cleaning start for each columns
    time_start = time.time()
    clean_list=[]
    clean_stem_list=[]
    for column_name in column_names:
        column = input_data[column_name].values
        if column_name == "Marque":
            array_clean = np.array(list(map(clean_marque,column)))
            clean_list.append(array_clean)
            clean_stem_list.append(array_clean)
        else:
            A = np.array(list(map(clean_txt,column)))
            array_clean = A[:,0]
            array_clean_stem = A[:,1]
            clean_list.append(array_clean)
            clean_stem_list.append(array_clean_stem)
    time_end = time.time()
    print("Cleaning time: %d secondes"%(time_end-time_start))

    #Convert list to DataFrame
    array_clean = np.array(clean_list).T
    data_clean = pd.DataFrame(array_clean, columns = column_names)

    array_clean_stem = np.array(clean_stem_list).T
    data_clean_stem = pd.DataFrame(array_clean_stem, columns = column_names)
    return data_clean, data_clean_stem


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Bien que déjà réduit par rapport au fichier original du concours, contenant plus de 15M de lignes, le fichier cdiscount_test.csv.zip, contenant 1M de lignes est encore volumineux.
Nous allons charger en mémoire qu'une partie de ce fichier grace à l'argument nb_line afin d'éviter des temps de calcul trop couteux.
Nous allons extraire 5% de ces 1M de lignes commes échantillons de validation.
Can you write Python code for it?

input_path = "data/cdiscount_train.csv.zip"
nb_line=100000  # part totale extraite du fichier initial ici déjà réduit
tauxValid = 0.05
data_train, data_valid = split_dataset(input_path, nb_line, tauxValid)
# Cette ligne permet de visualiser les 5 premières lignes de la DataFrame
N_train = data_train.shape[0]
N_valid = data_valid.shape[0]
print("Train set : %d elements, Validation set : %d elements" %(N_train, N_valid))


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Conversion du texte en minuscule
Certaines mots peuvent être écrits en majuscule dans les descriptions textes, cela à pour conséquence de dupliquer le nombre de features et une perte d'information.
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Enfin on crée des tokens, liste de mots dans la description produit, en supprimant les éléments de notre description produit qui sont présent dans la liste de stopword.
Can you write Python code for it?

tokens = [w for w in txt.split() if (len(w)>2) and (w not in stopwords)]
remove_words = [w for w in txt.split() if (len(w)<2) or (w in stopwords)]

print(tokens)
print(remove_words)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
La commande suivante permet d'afficher les premières lignes du fichiers.
Vous pouvez observer que chaque produit possède 3 niveaux de Catégories, qui correspondent au différents niveaux de l'arborescence que vous retrouverez sur le site.
Il y a 44 catégories de niveau 1, 428 de niveau 2 et 3170 de niveau 3.
Dans ce TP, nous nous interesserons uniquement à classer les produits dans la catégorie de niveau 1.
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Les données
Dans le dossier Cdiscount/data de ce répértoire vous trouverez les fichiers suivants :

cdiscount_test.csv.zip: Fichier d'apprentissage constitué de 1.000.000 de lignes
cdisount_test: Fichier test constitué de 50.000 lignes

### Read & Split Dataset
On définit une fonction permettant de lire le fichier d'apprentissage et de créer deux DataFrame Pandas, un pour l'apprentissage, l'autre pour la validation.
   La fonction créée un DataFrame en lisant entièrement le fichier. Puis elle scinde ce DataFrame en deux grâce à la fonction dédiée de sklearn.
Can you write Python code for it?

def split_dataset(input_path, nb_line, tauxValid):
    data_all = pd.read_csv(input_path,sep=",", nrows=nb_line)
    data_all = data_all.fillna("")
    data_train, data_valid = scv.train_test_split(data_all, test_size = tauxValid)
    time_end = time.time()
    return data_train, data_valid


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Nettoyage des DataFrames
Can you write Python code for it?

# Take approximately 2 minutes fors 100.000 rows
warnings.filterwarnings("ignore")
data_valid_clean, data_valid_clean_stem = clean_df(data_valid)

warnings.filterwarnings("ignore")
data_train_clean, data_train_clean_stem = clean_df(data_train)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Nettoyage des données
Afin de limiter la dimension de l'espace des variables ou features (i.e les mots présents dans le document), tout en conservant les informations essentielles, il est nécessaire de nettoyer les données en appliquant plusieurs étapes:

Chaque mot est écrit en minuscule.
Les termes numériques, de ponctuation et autres symboles sont supprimés.
155 mots-courants, et donc non informatifs, de la langue française sont supprimés (STOPWORDS). Ex: le, la, du, alors, etc...
Chaque mot est "racinisé", via la fonction STEMMER.stem de la librairie nltk. La racinisation transforme un mot en son radical ou sa racine. Par exemple, les mots: cheval, chevaux, chevalier, chevalerie, chevaucher sont tous remplacés par "cheva".

Exemple
Observons dans un premier temps l'effet de ces différentes étapes sur un  exemple.
Ligne Originale
Can you write Python code for it?

i = 0
description = data_train.Description.values[i]
print("Original Description : " + description)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
On applique également la suppression des accents à cette liste
Can you write Python code for it?

stopwords = [unicodedata.normalize('NFD', sw).encode('ascii', 'ignore').decode("utf-8") for sw in stopwords]
stopwords[:10]


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Racinisation (Stem) chaque tokens
Pour chaque mot de notre liste de token, on va ramener ce mot à sa racine au sens de l'algorithme de Snowball présent dans la librairie nltk.
Cette liste de mots néttoyé et racinisé va constitué les features de cette description produits.
Can you write Python code for it?

## Fonction de setmming de stemming permettant la racinisation
stemmer=nltk.stem.SnowballStemmer('french')
tokens_stem = [stemmer.stem(token) for token in tokens]
print(tokens_stem)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Remplace la description par une liste de mots (tokens), supprime les mots de moins de 2 lettres ainsi que les stopwords
On va supprimer maintenant tous les mots considérés comme "non-informatif". Par exemple : "le", "la", "de" ...
Des listes contenants ces mots sont proposés dans des libraires tels que nltk ou encore lucène.
Can you write Python code for it?

## listes de mots à supprimer dans la description des produits
## Depuis NLTK
nltk_stopwords = nltk.corpus.stopwords.words('french')
## Depuis Un fichier externe.
lucene_stopwords =open("data/lucene_stopwords.txt","r").read().split(",") #En local
## Union des deux fichiers de stopwords
stopwords = list(set(nltk_stopwords).union(set(lucene_stopwords)))

stopwords[:10]


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Remplacement de caractères spéciaux
Certains caractères spéciaux sont supprimés comme par exemple :

\u2026: …
\u00a0: NO-BREAK SPACE

Cette liste est non exhaustive et peut être etayée en fonction du jeu de donées étudié, de l'objectif souhaité ou encore du résultat de l'étude explorative.
Can you write Python code for it?

txt = txt.replace(u'\u2026','.')
txt = txt.replace(u'\u00a0',' ')
print(txt)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Suppression des posibles balises HTML dans la description
Les descriptions produits étant parfois extraites d'autres sites commerçant, des balises HTML peuvent être incluts dans la description.
La librairie 'BeautifulSoup' permet de supprimer ces balises
Can you write Python code for it?

from bs4 import BeautifulSoup #Nettoyage d'HTML
txt = BeautifulSoup(description,"html.parser",from_encoding='utf-8').get_text()
print(txt)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Supprime les caractères qui ne sont ne sont pas des lettres minuscules
Une fois ces premières étapes passées, on supprime tous les caractères qui sont pas des lettres minusculres, c'est à dire les signes de ponctuation, les caractères numériques etc...
Can you write Python code for it?

txt = re.sub('[^a-z_]', ' ', txt)
print(txt)


I am working on the file "Cdiscount/Part1-1-AIF-PythonNltk-Explore&CleanText-Cdiscount.ipynb".
The first task is:
Taille du dictionnaire de mots pour le dataset avant et après la racinisation.
Can you write Python code for it?

concatenate_text = " ".join(data_train["Description"].values)
list_of_word = concatenate_text.split(" ")
N = len(set(list_of_word))
print(N)

concatenate_text = " ".join(data_train_clean["Description"].values)
list_of_word = concatenate_text.split(" ")
N = len(set(list_of_word))
print(N)

concatenate_text = " ".join(data_train_clean_stem["Description"].values)
list_of_word_stem = concatenate_text.split(" ")
N = len(set(list_of_word_stem))
print(N)


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Build Features
Nous allons maintenant créer des matrices de features à partir des modèles de Word2Vec générés précédemment dans un but de prédiction.
La modèles créés permettent d'obtenir pour chaque mot x, sa représentation dans l'espace d'embeddings de la manière suivante :
x_feature = model_word2vec[x]
Dans notre problématique, les individus que nous cherchons à classer sont des descriptions représentées par une liste de token à l'issue du nettoyage du calepin précédent.  Il exsite donc plusieurs façon de représenter ces individus à l'aide de modèle Word2Vec.

Moyenne des vecteurs dans l'espace des features des différents mots/token de la description.
Moyenne pondérées des vecteurs dans l'espace des features des différents mots/token de la description en fonction de l'occurence de chacun de ces mots/tokens dans la description.
Moyenne pondérées par des poids calculés à l'aide du TF-IDF.
etc...

C'est la seconde solution qui sera utilisée ici.
Les fonctions détaillées ci-dessous permettent de :

get_features_mean : retourne le vecteur moyen dans l'espace d'embedding, des projections des mots/tokens composant lines
get_matrix_features_means : applique la fonction get_features_mean sur tous les éléments de la matrice X.
Can you write Python code for it?

def get_features_mean(lines, model, f_size):
    features = [model[x] for x  in lines if x in model]
    if features == []:
        fm =np.ones(f_size)
    else :
        fm = np.mean(features,axis=0)
    return fm

def get_matrix_features_means(X, model, f_size):
    X_embedded_ = list(map(lambda x : get_features_mean(x, model, f_size), X))
    X_embedded = np.vstack(X_embedded_)
    return X_embedded


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Build Word2Vec model
La fonction gensim.models.Word2Vecqui permet de construire des modèle Word2Vec prend en entrée une liste de tokens. On tranformer donc nos données dans un premier temps
Can you write Python code for it?

train_array_token = [line.split(" ") for line in train_array]
valid_array_token = [line.split(" ") for line in valid_array]
train_array_token[0]


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Build and Save Vectorize Vector
Afin de comparer l'effet de ces différentes vectorisation sur l'apprentissage, nous allons sauvegarder ces dernières sur les machines.
De nombreux paramètres sont à régler ce qui entraine donc un un très grand nombre de combinaison.
ici nous allons créer 4 jeu de données avec CountVectorizer et TFIDF chacun avec et sans hashage de taille 300.
Il est evidemment possible de tester d'autre combinaison. Libre à vous de les tester ;)
Fonction de Vectorisation
on créé deux fonctions vectorizer_train and apply_vectorizer afin de générer automatiquement différent dataframe d'apprentissage et de validation vectorisé.
Can you write Python code for it?

def vectorizer_train(df, columns=['Description'], nb_hash=None, nb_gram = 1, vectorizer = "tfidf" , binary = False):

    data_array = [" ".join(line) for line in df[columns].values]

    # Hashage
    if nb_hash is None:
        feathash = None
        if vectorizer == "tfidf":
            vec = TfidfVectorizer(ngram_range=(1,nb_gram))
            data_vec = vec.fit_transform(data_array)
        else:
            vec = CountVectorizer(binary=binary)
            data_vec = vec.fit_transform(data_array)
    else:
        data_dic_array = [collections.Counter(line.split(" ")) for line in data_array]
        feathash = FeatureHasher(nb_hash)
        data_hash = feathash.fit_transform(data_dic_array)

        if vectorizer=="tfidf":
            vec =  TfidfTransformer()
            data_vec =  vec.fit_transform(data_hash)
        else:
            vec = None
            data_vec = data_hash

    return vec, feathash, data_vec

def apply_vectorizer(df, vec, feathash, columns =['Description', 'Libelle', 'Marque']):

    data_array = [" ".join(line) for line in df[columns].values]

    #Hashage
    if feathash is None:
        data_hash = data_array
    else:
        data_dic_array = [collections.Counter(line.split(" ")) for line in data_array]
        data_hash = feathash.transform(data_dic_array)

    if vec is None:
        data_vec = data_hash
    else:
        data_vec = vec.transform(data_hash)
    return data_vec

parameters = [[None, "count"],
              [300, "count"],
              [None, "tfidf"],
              [300, "tfidf"]]

from scipy import sparse

for nb_hash, vectorizer in parameters:
    ts = time.time()
    vec, feathash, data_train_vec = vectorizer_train(data_train_clean_stem, nb_hash=nb_hash, vectorizer = vectorizer)
    data_valid_vec = apply_vectorizer(data_valid_clean_stem, vec, feathash)
    te = time.time()

    print("nb_hash : " + str(nb_hash) + ", vectorizer : " + str(vectorizer))
    print("Runing time for vectorization : %.1f seconds" %(te-ts))
  ...


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Cbow
Can you write Python code for it?

ts = time.time()
X_embedded_train_cbow = get_matrix_features_means(train_array_token, model_cbow, Features_dimension)
te = time.time()
t_build = te-ts
#np.save(embedded_train_dir, X_embedded_train)
print("Time conversion : %d seconds"%t_build)
print("Shape Matrix : (%d,%d)"%X_embedded_train_cbow.shape)
np.save(DATA_OUTPUT_DIR +"/embedded_train_cbow", X_embedded_train_cbow)

ts = time.time()
X_embedded_valid_cbow = get_matrix_features_means(valid_array_token, model_cbow, Features_dimension)
te = time.time()
t_build = te-ts
#np.save(embedded_train_dir, X_embedded_train)
print("Time conversion : %d seconds"%t_build)
print("Shape Matrix : (%d,%d)"%X_embedded_valid_cbow.shape)
np.save(DATA_OUTPUT_DIR +"/embedded_valid_cbow", X_embedded_valid_cbow)


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Dans un premier temps, en guise d'exemple et pour réduire le temps de calcul, on ne considère que la colonne Description de nos DataFrame générés dans le calepin précédent.
Can you write Python code for it?

train_array = data_train_clean_stem["Description"].values
valid_array = data_valid_clean_stem["Description"].values


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Exercice Pour la première ligne de votre dataset train. retrouvez l'ensemble des mots constituant cette ligne à partir de l'objet data_train_OHEet de vocabulary ainsi que le nombre d'occurence de chacun de ces mots dans la ligne.
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Exercice Testez d'autres combinaisons si vous le souhaitez.
Predict output word
La fonction predict_output_word de gensim permet de retrouver les mots prédit par le modèle à partir d'un mot ou d'une combinaison de mots données en argument.
Exercice  Affichez la prédiction des trois modèles pour des mots/combinaisons de mots communs (homme, femme) ou plus propre au jeu de données étudiés. (coque-de-téléphone)...
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Most similar world
La fonction most_similar de gensim permet de retrouver les mots les plus proches à un ou une combinaison de mots données en argument.
Q A l'aide de la documentation répondez aux questions suivantes. Quelle est la mesure de similarité utilisée? Dans quel espace est-elle utilisé? Comment fonctionne la fonction lorsque plusieurs mots sont passés en paramètres?
1 mot
Exercice Pour chacun de ces trois modèles, affichez les sorties de la fonction 'most_similar' pour le mot homme.
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Nous allons créer deux modèles :

Un modèle skip-sgram, sg = 1
Un modèle CBOW, sg = 0
Can you write Python code for it?

sg = 1
print("Start learning skip-gram Word2Vec")
ts = time.time()
model_sg = gensim.models.Word2Vec(train_array_token, sg=sg, hs=hs, negative=negative, min_count=1, size=Features_dimension)
te = time.time()
t_learning = te-ts
print("Learning time : %.2f Word2Vec" %t_learning)

sg = 0
print("Start learning CBOW Word2Vec")
ts = time.time()
model_cbow = gensim.models.Word2Vec(train_array_token, sg=sg, hs=hs, negative=negative, min_count=1, size=Features_dimension)
te = time.time()
t_learning = te-ts
print("Learning time : %.2f Word2Vec" %t_learning)


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
On créé un dossier dans lequel nous allons sauvegarder les DataFrame constitués des features que l'on va construire dans ce notebook
Can you write Python code for it?

DATA_OUTPUT_DIR = "data/features"
if not(os.path.isdir("data/features")):
    os.mkdir("data/features")


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
One-Hot-Encoding

One-Hot-Encoding

L'encodage  One-Hot-Encoding des données peut être effectué grâce à la classe CountVectorizerde scikit-learn
Can you write Python code for it?

from sklearn.feature_extraction.text import CountVectorizer

extr_cv = CountVectorizer(binary=False)
data_train_OHE = extr_cv.fit_transform(train_array)


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Propriété du modèle
Nous allons maintenant comparer quelques propriétés de chacun des trois modèles à notre disposition (CBOW, Skip-Gram et le modèle online)
Les modèles que nous avons appris l'ont été sur les mots racinisé. Ainsi, nous allons avoir besoin de la racine des mots pour tester les différentes propriétés du modèle.
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Q A quoi sert l'argument binary de la classe?
Q Sous quel format sont stockées les vecteurs OHE? Pourquoi ce format est-il choisi?
La fonction get_feature_names permet d'avoir accès à la liste des mots présents dans l'ensemble des lignes de l'array converti.
Can you write Python code for it?

vocabulary = extr_cv.get_feature_names()
N_vocabulary = len(vocabulary)
print("Nombre de mots : %d" %N_vocabulary )


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Q A quoi sert l'argument ngram_range?
Constatez que data_train_TFIDFest stocké sous le même format que data_train_OHE et que la taile du vocabulaire est la même.
Can you write Python code for it?

vocabulary = vec.get_feature_names()
N_vocabulary = len(vocabulary)
N_vocabulary


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Q Commentez les valeurs de l'idf pour chacun des mots.
Q Comment evolue les poids en changeant les paramètre smooth idf et sublinear_tf de la méthode TfidfVectorizer?
Exercice Changez l'argument ngram_range de la méthode TfidfVectorizer et re-affichez les résultats.
On applique maintenant le vectorizer sur le jeu de données de validation
Can you write Python code for it?

data_valid_TFIDF = vec.transform(valid_array)
data_valid_TFIDF


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Q Comparez la qualité de prévision des modèles que nous avons entrainés sur le jeu de données 'Cdiscount' avec celui appris online. Que pouvez-vous en dire?
Q Comparez les prévisions des deux modèles que nous avons entrainés. Que pouvez-vous en dire?
Exercice Affichez maintenant les sorties de la fonction 'most_similar' pour le mot femme.
Exercice Affichez les sorties de la fonction 'most_similar' pour des mots propre au jeu de données (ex. xbox, pantalon,..)
Combinaison de mots
Exercice Pour chacun de ces trois modèles, affichez les sorties de la fonction 'most_similar' pour l'opération suivante : roi + femme - homme à l'aide des arguments positive et negative de la fonction. Commentez encore une fois la qualité de sortie des différents modèle
Can you write Python code for it?


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Q Que pouvez-vous dire des poids?
La taille de la matrice a donc été très réduit par rapport au vectorizer, TFIDF ou One-Hot-Enconding. Cependant, il n'y a pas de fonction inverse transform ce qui peut rendre le résultat moin compréhensible.
Il est possible de combiner le FeatureHasheravec un autre vectorizer comme le TFIDF.
C'est cette fois la classe TFIDFTransformer qui est utilisé. Celle ci ne ne considère pas des string en entré mais l'array en sortie de l'étape de Hashage. Les mots sont les nb_hashindices sélectionnés et le tf pour chaque individu sont les poids calculé par la fonction de hasage.
Can you write Python code for it?

from sklearn.feature_extraction.text import TfidfTransformer

vec =  TfidfTransformer(norm = False)
data_train_HTfidf = vec.fit_transform(data_train_hash)
data_train_HTfidf

ir = 0

rw = data_train_HTfidf.getrow(ir)
print(train_array[ir])
pd.DataFrame([(ind, vec.idf_[ind], w/vec.idf_[ind], w)  for w,ind in zip(rw.data, rw.indices)], columns=["indices","idf","tf","weight"])


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Q Que se passe-til pour les mots présents dans le dataset de validation mais qui ne sont pas présent dans le dataset d'apprentissage?
Q Pourquoi on ne 're-fit' pas la Classe CountVectorizerl'échantillon de validation.
TF-IDF¶

TF-IDF. Le TF-IDF permet de faire ressortir l'importance relative de chaque mot $m$ (ou couples de mots consécutifs) dans un texte-produit ou un descriptif $d$, par rapport à la liste entière des produits. La fonction $TF(m,d)$ compte le nombre d'occurences du mot $m$ dans le descriptif $d$. La fonction $IDF(m)$ mesure l'importance du terme dans l'ensemble des documents ou descriptifs en donnant plus de poids aux termes les moins fréquents car considérés comme les plus discriminants (motivation analogue à celle de la métrique du chi2 en anamlyse des correspondance). $IDF(m,l)=\log\frac{D}{f(m)}$ où $D$ est le nombre de documents, la taille de l'échantillon d'apprentissage, et $f(m)$ le nombre de documents ou descriptifs contenant le mot $m$. La nouvelle variable ou features est $V_m(l)=TF(m,l)\times IDF(m,l)$.

Comme pour les transformations des variables quantitatives (centrage, réduction), la même transformation c'est-à-dire les mêmes pondérations, est calculée sur l'achantillon d'apprentissage et appliquée à celui de test.

On utiliser la fonction TfidfVectorizer qui permet de parser également le texte
Dans un premier temps, on fixe le paramètre norm = False afin de rendre les résultats plus explicite et analyser les sorties
Can you write Python code for it?

from sklearn.feature_extraction.text import TfidfVectorizer
vec = TfidfVectorizer(ngram_range=(1,1), norm = False)
data_train_TFIDF = vec.fit_transform(train_array)


I am working on the file "Cdiscount/Part1-2-AIF-PythonNltkGensim-FeatureExtraction-Cdiscount.ipynb".
The first task is:
Skip-Gram
Can you write Python code for it?

ts = time.time()
X_embedded_train_sg = get_matrix_features_means(train_array_token, model_sg, Features_dimension)
te = time.time()
t_build = te-ts
#np.save(embedded_train_dir, X_embedded_train)
print("Time conversion : %d seconds"%t_build)
print("Shape Matrix : (%d,%d)"%X_embedded_train_sg.shape)
np.save(DATA_OUTPUT_DIR +"/embedded_train_sg", X_embedded_train_sg)

ts = time.time()
X_embedded_valid_sg = get_matrix_features_means(valid_array_token, model_sg, Features_dimension)
te = time.time()
t_build = te-ts
#np.save(embedded_train_dir, X_embedded_train)
print("Time conversion : %d seconds"%t_build)
print("Shape Matrix : (%d,%d)"%X_embedded_valid_sg.shape)
np.save(DATA_OUTPUT_DIR +"/embedded_valid_sg", X_embedded_valid_sg)


I am working on the file "Cdiscount/Part1-3-AIF-PythonScikitLearn-Prediction-Cdiscount.ipynb".
The first task is:
Regression Logistique
Apprentissage
Le code suivant peut être très long. Vous pouvez dans un premier temps exécutez directement la cellule suivante ou les résultats de l'execution de cette cellules sont disponibles.
Can you write Python code for it?

metadata_list_lr = []

param_grid = {"C" : [10,1,0.1]}
#param_grid = {"C" : [1]}

for name, dic in features_path_dic.items():

    x_train_path = dic["x_train_path"]
    x_valid_path = dic["x_valid_path"]
    load = dic["load"]

    print("Load features : " + name)
    if load == "npz":
        X_train = sc.sparse.load_npz(x_train_path)
        X_valid = sc.sparse.load_npz(x_valid_path)
    else :
        X_train = np.load(x_train_path)
        X_valid = np.load(x_valid_path)

    print("start Learning :" + name)
    ts = time.time()
    gs = GridSearchCV(LogisticRegression(), param_grid=param_grid, verbose=15)
    gs.fit(X_train,Y_train.values)
    te=time.time()
    t_learning = te-ts

    print("start prediction :" + name)
    ts = time.time()
    score_train=gs.score(X_train,Y_train)
    score_valid=gs.score(X_valid,Y_valid)
    te=time.time()
    t_predict = te-ts

    metadata = {"name":name, "learning_time" : t_learning, "predict_time":t_predict, "score_train": score_train, "score_valid": score_valid}
    metadata_list_lr.append(metadata)
pickle.dump(metadata_list_lr, open("data/metadata_lr_part13.pkl","wb"))


I am working on the file "Cdiscount/Part1-3-AIF-PythonScikitLearn-Prediction-Cdiscount.ipynb".
The first task is:
Téléchargement des données
Téléchargement des variables réponses
Can you write Python code for it?

Y_train = pd.read_csv("data/cdiscount_train_subset.csv").fillna("")["Categorie1"]
Y_valid = pd.read_csv("data/cdiscount_valid.csv").fillna("")["Categorie1"]


I am working on the file "Cdiscount/Part2-1-AIF-PythonWorkflow-Cdiscount.ipynb".
The first task is:
### Read & Split Dataset
   Fonction permettant de lire le fichier d'apprentissage et de créer deux DataFrame Pandas, un pour l'apprentissage, l'autre pour la validation.
   La première méthode créée un DataFrame en lisant entièrement le fichier. Puis elle scinde le DataFrame en deux  grâce à la fonction dédiée de sklearn.
Can you write Python code for it?

def split_dataset(input_path, nb_line, tauxValid,columns):
    time_start = time.time()
    data_all = pd.read_csv(input_path,sep=",",names=columns,nrows=nb_line)
    data_all = data_all.fillna("")
    data_train, data_valid = train_test_split(data_all, test_size = tauxValid)
    time_end = time.time()
    print("Split Takes %d s" %(time_end-time_start))
    return data_train, data_valid

nb_line=20000  # part totale extraite du fichier initial ici déjà réduit
tauxValid=0.10 # part totale extraite du fichier initial ici déjà réduit
data_train, data_valid = split_dataset(training_reduit_path, nb_line, tauxValid, HEADER_TRAIN)
# Cette ligne permet de visualiser les 5 premières lignes de la DataFrame
data_train.head(5)


I am working on the file "Cdiscount/Part2-1-AIF-PythonWorkflow-Cdiscount.ipynb".
The first task is:
1. Importation des données
Définition du répertoir de travail, des noms des différents fichiers utilisés et des variables globales.
Dans un premier temps, il vous faut télécharger les fichiers Categorie_reduit.csv et lucene_stopwords.txt disponible dans le corpus de données de wikistat.
Une fois téléchargées, placez ces données dans le repertoire de travail de votre choix et préciser la direction de ce repertoir dans la variable DATA_DIR
Can you write Python code for it?

# Répertoire de travail
DATA_DIR = ""
# Nom des fichiers
training_reduit_path = DATA_DIR + "data/cdiscount_train.csv.zip"
# Variable Globale
HEADER_TEST = ['Description','Libelle','Marque']
HEADER_TRAIN =['Categorie1','Categorie2','Categorie3','Description','Libelle','Marque']

## Si nécessaire (première exécution) chargement de nltk, librairie pour la suppression
## des mots d'arrêt et la racinisation
# nltk.download()


I am working on the file "Cdiscount/Part2-1-AIF-PythonWorkflow-Cdiscount.ipynb".
The first task is:
2. Nettoyage des données
Afin de limiter la dimension de l'espace des variables ou features, tout en conservant les informations essentielles, il est nécessaire de nettoyer les données en appliquant plusieurs étapes:
* Chaque mot est écrit en minuscule.
* Les termes numériques, de ponctuation et autres symboles sont supprimés.
* 155 mots-courants, et donc non informatifs, de la langue française sont supprimés (STOPWORDS). Ex: le, la, du, alors, etc...
* Chaque mot est "racinisé", via la fonction STEMMER.stem de la librairie nltk. La racinisation transforme un mot en son radical ou sa racine. Par exemple, les mots: cheval, chevaux, chevalier, chevalerie, chevaucher sont tous remplacés par "cheva".
Importation des librairies et fichier pour le nettoyage des données.
Can you write Python code for it?

# Librairies
from bs4 import BeautifulSoup #Nettoyage d'HTML
import re # Regex
import nltk # Nettoyage des données

## listes de mots à supprimer dans la description des produits
## Depuis NLTK
nltk_stopwords = nltk.corpus.stopwords.words('french')
## Depuis Un fichier externe.
lucene_stopwords =open(DATA_DIR+"data/lucene_stopwords.txt","r").read().split(",") #En local
## Union des deux fichiers de stopwords
stopwords = list(set(nltk_stopwords).union(set(lucene_stopwords)))

## Fonction de setmming de stemming permettant la racinisation
stemmer=nltk.stem.SnowballStemmer('french')


I am working on the file "Cdiscount/Part2-1-AIF-PythonWorkflow-Cdiscount.ipynb".
The first task is:
Nettoyage des DataFrames
Applique le nettoyage sur toutes les lignes de la DataFrame
Can you write Python code for it?

# fonction de nettoyage du fichier(stemming et liste de mots à supprimer)
def clean_df(input_data, column_names= ['Description', 'Libelle', 'Marque']):
    #Test if columns entry match columns names of input data
    column_names_diff= set(column_names).difference(set(input_data.columns))
    if column_names_diff:
        warnings.warn("Column(s) '"+", ".join(list(column_names_diff)) +"' do(es) not match columns of input data", Warning)

    nb_line = input_data.shape[0]
    print("Start Clean %d lines" %nb_line)

    # Cleaning start for each columns
    time_start = time.time()
    clean_list=[]
    for column_name in column_names:
        column = input_data[column_name].values
        if column_name == "Marque":
            array_clean = np.array(list(map(clean_marque,column)))
        else:
            array_clean = np.array(list(map(clean_txt,column)))
        clean_list.append(array_clean)
    time_end = time.time()
    print("Cleaning time: %d secondes"%(time_end-time_start))

    #Convert list to DataFrame
    array_clean = np.array(clean_list).T
    data_clean = pd.DataFrame(array_clean, columns = column_names)
    return data_clean

# Take approximately 2 minutes fors 100.000 rows
data_valid_clean = clean_df(data_valid)
data_train_clean = clean_df(data_train)


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
4 Construction des features (TF-IDF)
4.1 Introduction
La vectorisation, c'est à dire la construction des features à partir de la liste des mots se fait en 2 étapes:
* Le hashage permet de réduire l'espace des variables (taille du dictionnaire) en un nombre limité et fixé a priori n_hash de features. Il repose sur la définition d'une hash function, $h$ qui à un indice $j$ défini dans l'espace des entiers naturels, renvoie un indice $i=h(j)$ dans dans l'espace réduit (1 à n_hash) des features. Ainsi le poids de l'indice $i$, du nouvel espace, est l'association de tous les poids d'indice $j$ tels que $i=h(j)$ de l'espace originale. Ici, les poids sont associés d'après la méthode décrit par Weinberger et al. (2009).
N.B. $h$ n'est pas généré aléatoirement. Ainsi pour un même fichier d'apprentissage (ou de test) et pour un même entier n_hash, le résultat de la fonction de hashage est identique

Le TF-IDF. Le TF-IDF  permet de faire ressortir l'importance relative de chaque mot $m$ (ou couples de mots consécutifs) dans un texte-produit ou un descriptif $d$, par rapport à la liste entière des produits. La fonction $TF(m,d)$ compte le nombre d'occurences du mot $m$ dans le descriptif $d$. La fonction $IDF(m)$  mesure l'importance du terme dans l'ensemble des documents ou descriptifs en donnant plus de poids aux termes les moins fréquents car considérés comme les plus discriminants (motivation analogue à celle de la métrique du chi2 en anamlyse des correspondance). $IDF(m,l)=\log\frac{D}{f(m)}$ où $D$ est le nombre de documents, la taille de l'échantillon d'apprentissage, et $f(m)$ le nombre de documents ou descriptifs contenant le mot $m$. La nouvelle variable ou features est $V_m(l)=TF(m,l)\times IDF(m,l)$.

Comme pour les transformations des variables quantitatives (centrage, réduction), la même transformation c'est-à-dire les mêmes pondérations, est calculée sur l'achantillon d'apprentissage et appliquée à celui de test.

4.2 Traitement
Dans le traitement qui suit, étape de hashage et calcul de $TF$ sont...
Can you write Python code for it?

trainDF.take(2)

ts=time.time()
# Term Frequency
hashing_tf = HashingTF(inputCol="cleanDescr", outputCol='tf', numFeatures=10000)
trainTfDF = hashing_tf.transform(trainDF)
# Inverse Document Frequency
idf = IDF(inputCol=hashing_tf.getOutputCol(), outputCol="tfidf")
idf_model = idf.fit(trainTfDF)
trainTfIdfDF = idf_model.transform(trainTfDF)
# application à l'échantillon tesy
testTfDF = hashing_tf.transform(testDF)
testTfIdfDF = idf_model.transform(testTfDF)
te=time.time()
rt = te-ts
print("Hashage et vectorisation prennent %d s, taille %d" %(rt, n_train))  #456 s, taille 1131577


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
4.2 Estimation de l'erreur sur l'échantillon test
Can you write Python code for it?

predictionsDF = model_lr.transform(testTfIdfDF)
labelsAndPredictions = predictionsDF.select("categoryIndex","prediction").collect()
nb_good_prediction = sum([r[0]==r[1] for r in labelsAndPredictions])
testErr = 1-nb_good_prediction/n_test
print('Test Error = ' + str(testErr)) # (0.08 avec taux =1)


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
Création des DataFrame train and Test
Une fois extrait l'échantillon test, l'échantillon d'apprentissage peut être sous échantillonné.
Can you write Python code for it?

tauxEch=0.8
(trainTotDF, testDF) = dataCleanindexed.randomSplit([tauxEch, 1-tauxEch])
n_test = trainTotDF.count()
print(n_test)  # 314441


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
Extraction sous-échantillon
Can you write Python code for it?

# Taux de sous-échantillonnage des données pour tester le programme de préparation
# sur un petit jeu de données
taux_donnees=0.99
dataEchDF,data_drop = RowDF.randomSplit([taux_donnees,1-taux_donnees])


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
Les instructions précédentes ne sont pas exécutées (exécution paresseuse ou lazy). Elles ne le sont que lors d'un traitement explicite.
Can you write Python code for it?

ts=time.time()
size = dataEchDF.count()
te=time.time()
rt_count = te-ts
print("Comptage prend %d s, pour une taille de %d" %(rt_count, size)) #63s


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
Nettoyage des données
Lecture des données
"dezippé" le fichier data/cdiscount_train.csv.zip avant d'éxecuter la cellule suivante.
Can you write Python code for it?

sqlContext = SQLContext(sc)
RowDF = sqlContext.read.format('com.databricks.spark.csv').options(header='true', inferschema='true').load('data/cdiscount_train.csv')
RowDF.take(2)


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
Sous-échantillonnage
Si toutes les données sont préparées, il est possible de sous-échantillonner l'échantillon d'apprentissage pour étudier l'impact de sa taille sur l'erreur de prévision.
Can you write Python code for it?

tauxApp=0.9
(trainDF, testDF)=trainTotDF.randomSplit([tauxApp, 1-tauxApp])
n_train=trainDF.count()
print(n_train)  # 1131577


I am working on the file "Cdiscount/Part2-2-AIF-PysparkWorkflow-Cdiscount.ipynb".
The first task is:
taux | Taille M | Temps
-----|--------|------
0.01 | 0.157  | 51
0.1  | 1.57   | 49
0.4  | 6.29   | 53
0.8  | 12.6   | 60
 1   | 15.7   | 64
Nettoyage
Afin de limiter la dimension de l'espace des variables ou features tout en conservant les informations essentielles, il est nécessaire de nettoyer les données en appliquant plusieurs étapes:
* Tokenizer: Les textes de descrpitions sont transformés en liste de mots. Chaque mot est écrit en minuscule, les termes numériques, de ponctuation et autres symboles sont supprimés.
* StopWord: 155 mots-courants, et donc non informatif, de la langue française sont supprimés (STOPWORDS). Ex: le, la, du, alors, etc...
* Stemmer: Chaque mot est "racinisé". La racinisation transforme un mot en son radical ou sa racine. Par exemple, les mots: cheval, chevaux, chevalier, chevalerie, chevaucher sont tous remplacés par "cheva".
La librairie pyspark.ml ne supporte actuellement pas de fonction de stemming pour pyspark. Pour cette étape nous faisons donc appel à la librairie nltk de python et la fonction nltk.stem.SnowballStemmer.
Can you write Python code for it?

import nltk
from pyspark.sql.types import ArrayType
from pyspark.sql.functions import udf,col
from pyspark.ml.feature import RegexTokenizer, StopWordsRemover

# liste des mots à supprimer
STOPWORDS = set(nltk.corpus.stopwords.words('french'))
# Fonction tokenizer qui permet de remplacer un long texte par une liste de mot
regexTokenizer = RegexTokenizer(inputCol="Description", outputCol="tokenizedDescr", pattern="[^a-z_]",
                                minTokenLength=3, gaps=True)
dataTokenized = regexTokenizer.transform(dataEchDF)

# Fonction StopWordsRemover qui permet de supprimer des mots
remover = StopWordsRemover(inputCol="tokenizedDescr", outputCol="tokenizedRemovedDescr", stopWords = list(STOPWORDS))
dataTokenizedRemoved = remover.transform(dataTokenized)

# La fonction de stemming de spark existe aujourd'hui qu'en scala et ne possède pas de wrapper en python.
# Cette étape doit donc être effectué en utilisant des librairies python et notamment nltk
STEMMER = nltk.stem.SnowballStemmer('french')

def clean_text(tokens):
    tokens_stem = [ STEMMER.stem(token) for token in tokens]
    return tokens_stem
udfCleanText =  udf(lambda lt : clean_text(lt), ArrayType(StringType()))
dataClean = dataTokenizedRemoved.withColumn("cleanDescr", udfCleanText(col('tokenizedRemovedDescr')))

dataClean.take(2)

# Create a new rdd with the resulte of the clean_text function on the description
ts=time.time()
size = dataClean.count()
te=time.time()
rt = te-ts
print("Nettoyage prend %d s, pour la taille %d" %(rt, size)) #64s


I am working on the file "Cdiscount/Part2-2bis-AIF-PysparkWorkflowPipeline-Cdiscount.ipynb".
The first task is:
Création du pipeline
Création d'un Transformer pour l'étape de stemming.
Dans le calepin précédent, nous avons définie une fonction stemmer à partir de la librairie nltk. Pour que celle-ci puisse être utilisé dans un Pipeline ML, nous devons en faire un objet transformers.
Can you write Python code for it?

from pyspark import keyword_only
from pyspark.ml import Transformer
from pyspark.ml.param.shared import HasInputCol, HasOutputCol, Param
from pyspark.sql.functions import udf, col
from pyspark.sql.types import ArrayType, StringType

class MyNltkStemmer(Transformer, HasInputCol, HasOutputCol):

    @keyword_only
    def __init__(self, inputCol=None, outputCol=None):
        super(MyNltkStemmer, self).__init__()
        kwargs = self._input_kwargs
        self.setParams(**kwargs)

    @keyword_only
    def setParams(self, inputCol=None, outputCol=None):
        kwargs = self._input_kwargs
        return self._set(**kwargs)

    def _transform(self, dataset):
        STEMMER = nltk.stem.SnowballStemmer('french')
        def clean_text(tokens):
            tokens_stem = [ STEMMER.stem(token) for token in tokens]
            return tokens_stem
        udfCleanText =  udf(lambda lt : clean_text(lt), ArrayType(StringType()))
        out_col = self.getOutputCol()
        in_col = dataset[self.getInputCol()]
        return dataset.withColumn(out_col, udfCleanText(in_col))


I am working on the file "Cdiscount/Part2-2bis-AIF-PysparkWorkflowPipeline-Cdiscount.ipynb".
The first task is:
Estimation de l'erreur sur l'échantillon test
Can you write Python code for it?

predictionsDF = model.transform(DataTest)
labelsAndPredictions = predictionsDF.select("categoryIndex","prediction").collect()
nb_good_prediction = sum([r[0]==r[1] for r in labelsAndPredictions])
testErr = 1-nb_good_prediction/n_test
print('Test Error = , pour un echantillon test de taille n = %d' + str(testErr)) # (0.08 avec taux =1)


I am working on the file "Cdiscount/Part2-2bis-AIF-PysparkWorkflowPipeline-Cdiscount.ipynb".
The first task is:
Extraction sous-échantillon
Can you write Python code for it?

# Taux de sous-échantillonnage des données pour tester le programme de préparation
# sur un petit jeu de données
taux_donnees=[0.80,0.19,0.01]
dataTrain, DataTest, data_drop = RowDF.randomSplit(taux_donnees)
n_train = dataTrain.count()
n_test= DataTest.count()
print("DataTrain : size = %d, DataTest : size = %d"%(n_train, n_test))


I am working on the file "Cdiscount/Part3-AIF-PythonKeras-TextGeneration-Cdiscount-Copy1.ipynb".
The first task is:
Apprentissage
Nous allons maintenant définir notre modèle récurrent afin de générer notre modèle de prédiction.
Prenez le temps de bien comprendre toutes les fonctions et arguments utilisés pour construire ce modèle.
Can you write Python code for it?

nb_hidden = 32
epochs = 20
batch_size= 128

model = km.Sequential()
model.add(kl.LSTM(nb_hidden, input_shape=(None, Nv), return_sequences=True))
model.add(kl.TimeDistributed(kl.Dense(Nv)))
model.add(kl.Activation('softmax'))
model.summary()

model.compile(loss="categorical_crossentropy", optimizer="rmsprop")
model.fit(X_vec, Y_vec, epochs=epochs, batch_size=batch_size)
model.save("data/generate_model.h5")


I am working on the file "Cdiscount/Part3-AIF-PythonKeras-TextGeneration-Cdiscount-Copy1.ipynb".
The first task is:
Encodage des Descriptions
La fonction suivante, permet d'encoder une matrice $X\in \mathbb{R}^{N \times N_d}$ constitués de N descriptions en une matrice $X_{vec} \in \mathbb{R}^{N \times N_d \times N_v}$ contenant les description encodées.
Can you write Python code for it?

def encode_input_output_sequence(x, length_sequence, size_vocab, char_to_int_dic, i_start, i_end):
    n = x.shape[0]
    x_vec = np.zeros((n,length_sequence, size_vocab))
    y_vec = np.zeros((n,length_sequence, size_vocab))
    x_vec[:,0,i_start] = 1
    y_vec[:,-1,i_end] = 1
    for ix,x in tqdm(enumerate(x)):
        for ic,c in enumerate(x):
            c_int = char_to_int_dic[c]
            x_vec[ix,ic+1,c_int]=1
    y_vec[:,:-1,:] = x_vec[:,1:,:]
    return x_vec, y_vec

X_vec, Y_vec = encode_input_output_sequence(X[:N], Nd+1, Nv, char_to_int,I_START,I_END)

X_vec.shape


I am working on the file "Cdiscount/Part3-AIF-PythonKeras-TextGeneration-Cdiscount-Copy1.ipynb".
The first task is:
Exercice Effectuez une génération en ajoutant de l'aléa. Vous pouvez par exemple faire en sorte que chaque lettre soit séléctionnée selon une loi multinomiale.
Can you write Python code for it?


I am working on the file "Cdiscount/Part3-AIF-PythonKeras-TextGeneration-Cdiscount-Copy1.ipynb".
The first task is:
Exercice Vérifiez que toutes les séquences sont bien de tailles 197.
Can you write Python code for it?


I am working on the file "Cdiscount/Part3-AIF-PythonKeras-TextGeneration-Cdiscount-Copy1.ipynb".
The first task is:
Mise en forme  des données
La génération de texte implique de constuire un réseau Many-To-One :
<img src="https://raw.githubusercontent.com/wikistat/AI-Frameworks/master/slides/OneToMany.png" alt="drawing" width="400"/>
Ou la prédiction $y_t$ servira d'entrée au réseau au temps $t+1$, i.e : $y_t=x_{t+1}$.
Chaque $x_t$ représente ici un caractère de la déscription encodé en One-Hot encoding. Ainsi une description $x$ composé de $N_d$ caractères sera modélisé par une matrice de taille $(N_v\times N_d)$  $x=[x_1,x_2,...,x_{N_d}]$  ou $x_i \in \mathbb{R}^{N_v}$
Création de la liste des caractères
Afin d'encoder les description sous format 'One-Hot encoding'  nous devons dans un premier temps retrouver la taille $Nv$ de notre vocabulaire constitué de tout les caractères présent dans la description.
Can you write Python code for it?

chars = list(functools.reduce(lambda x,y : x.union(y), [set(x) for x in X], set()))
print("Vocabulaire : " +  str(chars))