markdown
stringlengths
0
1.02M
code
stringlengths
0
832k
output
stringlengths
0
1.02M
license
stringlengths
3
36
path
stringlengths
6
265
repo_name
stringlengths
6
127
Another Try (Full tree leaning towards 5)
indices = np.where(list(map(lambda x: x>=3,Y_train)))[0] X_train_counts_3_45 = X_train_counts[indices] Y_train_3_45 = [0 if Y_train[j]==3 else 1 for j in indices] indices = np.where(list(map(lambda x:x>3,Y_train)))[0] X_train_counts_4_5 = X_train_counts[indices] Y_train_4_5 = [Y_train[j] for j in indices] indices = np.where(list(map(lambda x:x<3,Y_train)))[0] X_train_counts_1_2 = X_train_counts[indices] Y_train_1_2 = [Y_train[j] for j in indices] # print(X_train_counts[0]) # print('hey') # print(X_train_counts_1_2[0]) def modif(x): if (x>=3): return 1 else: return 0 Y_modified = list(map(lambda x: modif(x),Y_train)) model_12_345 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_12_345.fit(X_train_counts,Y_modified) model_4_5 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_4_5.fit(X_train_counts_4_5,Y_train_4_5) model_3_45 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_3_45.fit(X_train_counts_3_45,Y_train_3_45) model_1_2 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_1_2.fit(X_train_counts_1_2,Y_train_1_2) pred_12_345 = model_12_345.predict_proba(X_dev_counts) pred_3_45 = model_3_45.predict_proba(X_dev_counts) pred_1_2 = model_1_2.predict_proba(X_dev_counts) pred_4_5 = model_4_5.predict_proba(X_dev_counts) pred = [] for i in tqdm(range(len(pred_12_345))): pred.append(pred_12_345[i][1]*pred_3_45[i][1]*pred_4_5[i][1]*5.0+ pred_12_345[i][1]*pred_3_45[i][1]*pred_4_5[i][0]*4.0+ pred_12_345[i][1]*pred_3_45[i][0]*3.0+ pred_12_345[i][0]*pred_1_2[i][1]*2.0+ pred_12_345[i][0]*pred_1_2[i][0]*1.0) get_metrics_from_pred(pred,Y_dev)
_____no_output_____
MIT
A1_part_1/Non Pipelined Tester.ipynb
ankurshaswat/COL772
Another Try
indices = np.where(list(map(lambda x: x>=3,Y_train)))[0] X_train_counts_3_45 = X_train_counts[indices] Y_train_3_45 = [0 if Y_train[j]==3 else 1 for j in indices] indices = np.where(list(map(lambda x:x>3,Y_train)))[0] X_train_counts_4_5 = X_train_counts[indices] Y_train_4_5 = [Y_train[j] for j in indices] indices = np.where(list(map(lambda x:x>1,Y_train)))[0] X_train_counts_2_345 = X_train_counts[indices] Y_train_2_345 = [ 0 if Y_train[j]== 2 else 1 for j in indices] def modif(x): if (x>1): return 1 else: return 0 Y_modified = list(map(lambda x: modif(x),Y_train)) model_1_2345 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_1_2345.fit(X_train_counts,Y_modified) model_2_345 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_2_345.fit(X_train_counts_2_345,Y_train_2_345) model_3_45 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_3_45.fit(X_train_counts_3_45,Y_train_3_45) model_4_5 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_4_5.fit(X_train_counts_4_5,Y_train_4_5) pred_1_2345 = model_1_2345.predict_proba(X_dev_counts) pred_2_345 = model_2_345.predict_proba(X_dev_counts) pred_3_45 = model_3_45.predict_proba(X_dev_counts) pred_4_5 = model_4_5.predict_proba(X_dev_counts) pred = [] for i in tqdm(range(len(pred_1_2345))): pred.append(pred_1_2345[i][0]*1.0+ pred_1_2345[i][1]*pred_2_345[i][0]*2.0+ pred_1_2345[i][1]*pred_2_345[i][1]*pred_3_45[i][0]*3.0+ pred_1_2345[i][1]*pred_2_345[i][1]*pred_3_45[i][1]*pred_4_5[i][0]*4.0+ pred_1_2345[i][1]*pred_2_345[i][1]*pred_3_45[i][1]*pred_4_5[i][1]*5.0) get_metrics_from_pred(pred,Y_dev)
_____no_output_____
MIT
A1_part_1/Non Pipelined Tester.ipynb
ankurshaswat/COL772
Another Try
indices = np.where(list(map(lambda x: x<=3,Y_train)))[0] X_train_counts_12_3 = X_train_counts[indices] Y_train_12_3 = [1 if Y_train[j]==3 else 0 for j in indices] indices = np.where(list(map(lambda x:x<3,Y_train)))[0] X_train_counts_1_2 = X_train_counts[indices] Y_train_1_2 = [Y_train[j] for j in indices] indices = np.where(list(map(lambda x:x>1,Y_train)))[0] X_train_counts_123_4 = X_train_counts[indices] Y_train_123_4 = [ 1 if Y_train[j]== 4 else 0 for j in indices] def modif(x): if (x>4): return 1 else: return 0 Y_modified = list(map(lambda x: modif(x),Y_train)) model_1234_5 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_1234_5.fit(X_train_counts,Y_modified) model_123_4 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_123_4.fit(X_train_counts_123_4,Y_train_123_4) model_12_3 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_12_3.fit(X_train_counts_12_3,Y_train_12_3) model_1_2 = LogisticRegression(verbose=1,n_jobs=7,solver='sag') model_1_2.fit(X_train_counts_1_2,Y_train_1_2) pred_1234_5 = model_1234_5.predict_proba(X_dev_counts) pred_123_4 = model_123_4.predict_proba(X_dev_counts) pred_12_3 = model_12_3.predict_proba(X_dev_counts) pred_1_2 = model_1_2.predict_proba(X_dev_counts) pred = [] for i in tqdm(range(len(pred_1234_5))): pred.append(pred_1234_5[i][1]*5.0+ pred_1234_5[i][0]*pred_123_4[i][1]*4.0+ pred_1234_5[i][0]*pred_123_4[i][0]*pred_12_3[i][1]*3.0+ pred_1234_5[i][0]*pred_123_4[i][0]*pred_12_3[i][0]*pred_1_2[i][1]*2.0+ pred_1234_5[i][0]*pred_123_4[i][0]*pred_12_3[i][0]*pred_1_2[i][0]*1.0) get_metrics_from_pred(pred,Y_dev)
_____no_output_____
MIT
A1_part_1/Non Pipelined Tester.ipynb
ankurshaswat/COL772
Tipología de datos · Práctica 22021-6 · Máster universitario en Ciencia de datos (Data Science)Estudios de Informática, Multimedia y Telecomunicación&nbsp; Práctica 2: Limpieza y Análisis de DatosEn esta práctica se elabora un caso práctico orientado a aprender a identificar los datos relevantes para un proyecto analítico y usar las herramientas de integración, limpieza, validación y análisis de las mismas. Objetivos Los objetivos concretos de esta práctica son: - Aprender a aplicar los conocimientos adquiridos y su capacidad de resolución de problemas en entornos nuevos o poco conocidos dentro de contextos más amplios o multidisciplinares. - Saber identificar los datos relevantes y los tratamientos necesarios (integración, limpieza y validación) para llevar a cabo un proyecto analítico. - Aprender a analizar los datos adecuadamente para abordar la información contenida en los datos. - Identificar la mejor representación de los resultados para aportar conclusiones sobre el problema planteado en el proceso analítico. - Actuar con los principios éticos y legales relacionados con la manipulación de datos en el ámbito de aplicación. - Desarrollar las habilidades de aprendizaje que les permitan continuar estudiando de un modo que tendrá que ser en gran medida autodirigido o autónomo. - Desarrollar la capacidad de búsqueda, gestión y uso de información y recursos en el ámbito de la ciencia de datos. Descripción de la Práctica a realizar El objetivo de esta actividad será el tratamiento de un dataset, que puede ser el creado en la práctica 1 o bien cualquier dataset libre disponible en Kaggle (https://www.kaggle.com). Algunos ejemplos de dataset con los que podéis trabajar son: - Red Wine Quality (https://www.kaggle.com/uciml/red-wine-quality-cortez-et-al-2009) - Titanic: Machine Learning from Disaster (https://www.kaggle.com/c/titanic) El último ejemplo corresponde a una competición activa de Kaggle de manera que, opcionalmente, podéis aprovechar el trabajo realizado durante la práctica para entrar en esta competición. Siguiendo las principales etapas de un proyecto analítico, las diferentes tareas a realizar (y justificar) son las siguientes: **1.** Descripción del dataset. ¿Por qué es importante y qué pregunta/problema pretende responder? **2.** Integración y selección de los datos de interés a analizar. **3.** Limpieza de los datos. - 3.1.¿Los datos contienen ceros o elementos vacíos? ¿Cómo gestionarías cada uno de estos casos? - 3.2.Identificación y tratamiento de valores extremos. **4.** Análisis de los datos. - 4.1.Selección de los grupos de datos que se quieren analizar/comparar (planificación de los análisis a aplicar). - 4.2.Comprobación de la normalidad y homogeneidad de la varianza. - 4.3.Aplicación de pruebas estadísticas para comparar los grupos de datos. En función de los datos y el objetivo del estudio, aplicar pruebas de contraste de hipótesis, correlaciones, regresiones, etc. Aplicar al menos tres métodos de análisis diferentes. **5.** Representación de los resultados a partir de tablas y gráficas. **6.** Resolución del problema. A partir de los resultados obtenidos, ¿cuáles son las conclusiones? ¿Los resultados permiten responder al problema?**7.** Código: Hay que adjuntar el código, preferiblemente en R, con el que se ha realizado la limpieza, análisis y representación de los datos. Si lo preferís, también podéis trabajar en Python. LUIS ALBERTO PICO Configuración Inicial y Librerías
import pandas as pd import numpy as np import seaborn as sns import matplotlib.pyplot as plt import missingno as msno from statsmodels.graphics.gofplots import qqplot #Normalidad from scipy import stats #Pruebas Estadísticas from sklearn.preprocessing import OneHotEncoder from sklearn import preprocessing from sklearn.feature_selection import RFE from sklearn.linear_model import LogisticRegression import statsmodels.api as sm from sklearn.linear_model import LogisticRegression from sklearn import metrics from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, confusion_matrix custom_palette = ["blue", "orange", "green", "purple","yellow","red"] sns.set_palette(custom_palette) sns.set_context("notebook") hue_colors = {0: "red",1: "cyan",2: "yellow"}
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
1. Descripción del Dataset DatasetTitanic AutorKaggle. Titanic - Machine Learning from Disaster. https://www.kaggle.com/c/titanic/overview DescripciónEste dataset contiene dos conjuntos de datos similares que incluyen información del pasajero como nombre, edad, género, clase, etc. Un conjunto de datos se titula `train.csv` y el otro se titula `test.csv` .**train.csv** contiene los atributos de un subconjunto de pasajeros a bordo (891) y la variable objetivo que indica si sobrevivieron o no.El conjunto de datos **test.csv** contiene información de los atributos de los pasajeros, más no si sobreviviron o no y este conjunto de datos nos servirá para determinar la precisión del modelo de predicción. Dimensiones**train.csv**. El Dataset esta compuesto de 891 registros (pasajeros) y 10 atributos (9 variables de entrada y 1 variable de salida) **test.csv** . El Dataset esta compuesto de 418 registros (pasajeros) y 9 atributos (9 variables de entrada) AtributosAtributo de salida: survival. 1 si pasajero sobrevivió y 0 de lo contrario Atributos de Entrada (pasajeros): * PassengerId. Identificador único de pasajero * Pclass. Clase asociada al boleto (1 = 1st, 2 = 2nd, 3 = 3rd) * Sex. Sexo del pasajero * Age. Edad en años * SibSp. Número de hermanos(as) /cónyuges a bordo. * Parch. Número de padres/hijos a bordo. * Ticket. Número de ticket * Fare. tarifa * Cabin. número de cabina * Embarked. Puerto de embarque (C = Cherbourg, Q = Queenstown, S = Southampton) ImportanciaEl hundimiento del Titanic es uno de los naufragios más infames de la historia.El 15 de abril de 1912, durante su viaje inaugural, el RMS Titanic, ampliamente considerado "insumergible", se hundió después de chocar con un iceberg. Desafortunadamente, no había suficientes botes salvavidas para todos a bordo, lo que resultó en la muerte de 1,502 de los 2,224 pasajeros y la tripulación.Si bien hubo algún elemento de suerte involucrado en sobrevivir, parece que algunos grupos de personas tenían más probabilidades de sobrevivir que otros, esta hipótesis será corroborrada creando un modelo predictivo que responda a la pregunta: "¿Qué tipo de personas tenían más probabilidades de sobrevivir?" utilizando los datos de los pasajeros. 2. Integración y selección de Datos 2.1 Carga del Conjunto de DatosProcedemos a realizar la lectura de los ficheros en formato CSV `train.csv` y `test.csv` previamente descargado desde Kaggle, los almacenaremos en los dataframes **Titanic_train** y **Titanic_test**, finalmente visualizamos una muestra de los datos que contienen.
titanic_train_original=pd.read_csv('train.csv') titanic_test_original=pd.read_csv('test.csv') titanic_train=titanic_train_original.copy() titanic_test=titanic_test_original.copy() titanic_train.head() titanic_test.head()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Procedemos a revisar la estructura y tipos de datos que contiene de los conjuntos de datos, además de los valores únicos de cada atributo.
print('train \n') titanic_train.info() print('\n') print('test \n') titanic_test.info() pd.DataFrame(titanic_train.nunique(),columns=['Valores Únicos']) pd.DataFrame(titanic_test.nunique(),columns=['Valores Únicos'])
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Los datos del pasajero estan consituidos por 5 atributos de texto y 6 atributos numéricos, se considera como atributos categóricos a `Pclass` y `Survived`, los nombres de los atributos los guardaremos en dos listas que indiquen cuales son cualitativos y cuales son cuantitativos, adicional el conjunto de train contiene la variable objetivo que toma un valor numérico. No se consideran para el análisis los atributos `Name`,`PassengerId` y `Ticket` por cuanto son identificadores únicos de los pasajeros y sus boletos que no aportarán nada al análisis.
titanic_train['Pclass']=titanic_train['Pclass'].astype('category') titanic_test['Pclass'] =titanic_test['Pclass'].astype('category') titanic_train['Survived']=titanic_train['Survived'].astype('category') atributos_cualitativos=['Sex','Cabin','Embarked','Pclass','Survived'] atributos_cuantitativos=['Age','SibSp','Parch','Fare'] titanic_train=titanic_train.drop(columns=['Name','PassengerId','Ticket']).copy() titanic_test =titanic_test.drop(columns=['Name','PassengerId','Ticket']).copy() titanic_train.info()
<class 'pandas.core.frame.DataFrame'> RangeIndex: 891 entries, 0 to 890 Data columns (total 9 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Survived 891 non-null category 1 Pclass 891 non-null category 2 Sex 891 non-null object 3 Age 714 non-null float64 4 SibSp 891 non-null int64 5 Parch 891 non-null int64 6 Fare 891 non-null float64 7 Cabin 204 non-null object 8 Embarked 889 non-null object dtypes: category(2), float64(2), int64(2), object(3) memory usage: 50.8+ KB
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
2.2 Análisis estadístico básicoProcedemos a visualizar estadístos básicos para los atributos cuantitativos `(media, mediana, desvianción estándar, mínimo, máximo, cuartiles)` a través de la función `describe` del dataframe.
titanic_train.describe() titanic_test.describe()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Procedemos a visualizar estadístos básicos para los atributos cuanlitativos `unique(cantidad de valores únicos),top y frecuencia` a través de la función `describe` del dataframe.
titanic_train[atributos_cualitativos].describe() titanic_test[atributos_cualitativos[:-1]].describe()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
2.3 Selección de DatosDado que el objetivo del análisis será generar una modelo predictivo que permita determinar si un pasajero sobrevivió o no en función de sus atributos sociodemográficos y del viaje, se utilizará como la variable objetivo o dependiente la variable `Survived`* **Sobrevivió (1)**. * **No Sobrevivió (0)**.Las variables independientes se definen por los siguientes atributos del conjunto de datos: `Sex`, `Cabin`, `Embarked`, `Pclass`, `Survived`, `Age`, `SibSp` ,`Parch` y `Fare`. 3. Limpieza de DatosProcederemos en este apartado a determinar si los datos contienen ceros o elementos vacíos y gestionarlos en caso de existir alguno, luego identificaremos y trataremos en la medida de los posible los valores extremos. 3.1 Ceros o Elementos Vacíos
pd.DataFrame(np.sum(titanic_train[atributos_cuantitativos]==0),columns=['Ceros']) pd.DataFrame(np.sum(titanic_test[atributos_cuantitativos]==0),columns=['Ceros'])
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Las variables `SibSp` (Número de hermanos(as) /cónyuges a bordo) ,`Parch` (Parch. Número de padres/hijos a bordo) y `Fare` (Tarifa) contienen valores cero, en función de sus definiciones el valor de cero es válido tanto para SibsSp y Parch, pero por la baja cantidad de valores cero se puede considerar que la tarifa fue cero para algunos invitados especiales, por lo que no se realizará ningún tipo de tratamiento para estos valores.Para deteminar si los datos contienen los elementos vacíos utilizaremos la función `matrix` y `bar` de la librería **missingno** y la función `isna` del dataframe asociado a nuestros conjuntos de datos.
fig = plt.figure(figsize=(4,2)) fig.subplots_adjust(hspace=0.4, wspace=0.4) ax = fig.add_subplot(1, 2, 1) msno.matrix(titanic_train,ax=ax,sparkline=False) ax = fig.add_subplot(1, 2, 2) msno.bar(titanic_train) plt.show() fig = plt.figure(figsize=(4,2)) fig.subplots_adjust(hspace=0.4, wspace=0.4) ax = fig.add_subplot(1, 2, 1) msno.matrix(titanic_test,ax=ax,sparkline=False) ax = fig.add_subplot(1, 2, 2) msno.bar(titanic_test) plt.show() pd.DataFrame(titanic_train.isna().sum(),columns=['Nulos']) pd.DataFrame(titanic_test.isna().sum(),columns=['Nulos'])
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Las variables `Age` (Edad), `Cabin` (Número de cabina), `Fare` (Tarifa) y `Embarked` contienen valores nulos, para los atributos `Age`, `Fare` y `Embarked` realizaremos un proceso de imputación, en cambio la variable `Cabin` será excluida del análisis por cuanto el **77.81%** (687/891) de los pasajeros no tienen un valor, el **16.49%** (147/891) corresponde a valores únicos y por tanto dado que es una variable cualitativa su aporte no será significativo para el modelo.
titanic_train=titanic_train.drop(columns=['Cabin']).copy() titanic_test=titanic_test.drop(columns=['Cabin']).copy()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
**Imputación Atributo Age**El atributo `Age` lo imputaremos con el valor de la media de los pasajeros del conjunto de datos de train.
missing_age = titanic_train[titanic_train['Age'].isna()] complete_age = titanic_train[~titanic_train['Age'].isna()] print('Missing') print(missing_age.describe()) print('Complete') print(complete_age.describe()) media_age=titanic_train['Age'].mean() titanic_train = titanic_train.fillna({'Age': media_age}) titanic_test = titanic_test.fillna({'Age': media_age})
Missing Age SibSp Parch Fare count 0.0 177.000000 177.000000 177.000000 mean NaN 0.564972 0.180791 22.158567 std NaN 1.626316 0.534145 31.874608 min NaN 0.000000 0.000000 0.000000 25% NaN 0.000000 0.000000 7.750000 50% NaN 0.000000 0.000000 8.050000 75% NaN 0.000000 0.000000 24.150000 max NaN 8.000000 2.000000 227.525000 Complete Age SibSp Parch Fare count 714.000000 714.000000 714.000000 714.000000 mean 29.699118 0.512605 0.431373 34.694514 std 14.526497 0.929783 0.853289 52.918930 min 0.420000 0.000000 0.000000 0.000000 25% 20.125000 0.000000 0.000000 8.050000 50% 28.000000 0.000000 0.000000 15.741700 75% 38.000000 1.000000 1.000000 33.375000 max 80.000000 5.000000 6.000000 512.329200
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
**Imputación Atributo Fare**El atributo `Fare` lo imputaremos con el valor de la media de los pasajeros del conjunto de datos de train.
missing_fare = titanic_test[titanic_test['Fare'].isna()] complete_fare = titanic_test[~titanic_test['Fare'].isna()] print('Missing') print(missing_fare.describe()) print('Complete') print(complete_fare.describe()) media_fare=titanic_train['Fare'].mean() titanic_test = titanic_test.fillna({'Fare': media_fare})
Missing Age SibSp Parch Fare count 1.0 1.0 1.0 0.0 mean 60.5 0.0 0.0 NaN std NaN NaN NaN NaN min 60.5 0.0 0.0 NaN 25% 60.5 0.0 0.0 NaN 50% 60.5 0.0 0.0 NaN 75% 60.5 0.0 0.0 NaN max 60.5 0.0 0.0 NaN Complete Age SibSp Parch Fare count 417.000000 417.000000 417.000000 417.000000 mean 30.081832 0.448441 0.393285 35.627188 std 12.563849 0.897568 0.982419 55.907576 min 0.170000 0.000000 0.000000 0.000000 25% 23.000000 0.000000 0.000000 7.895800 50% 29.699118 0.000000 0.000000 14.454200 75% 35.000000 1.000000 0.000000 31.500000 max 76.000000 8.000000 9.000000 512.329200
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
**Imputación Atributo Embarked**El atributo `Embarked` lo imputaremos con el valor de la moda de los pasajeros del conjunto de datos de train.
missing_embarked = titanic_train[titanic_train['Embarked'].isna()] complete_embarked = titanic_train[~titanic_train['Embarked'].isna()] print('Missing') print(missing_embarked.describe()) print('Complete') print(complete_embarked.describe()) moda_embarked='S' titanic_train = titanic_train.fillna({'Embarked': moda_embarked}) fig = plt.figure(figsize=(4,2)) fig.subplots_adjust(hspace=0.4, wspace=0.4) ax = fig.add_subplot(1, 2, 1) ax.set_title('Train') msno.bar(titanic_train) ax = fig.add_subplot(1, 2, 2) ax.set_title('Test') msno.bar(titanic_test) plt.show()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
3.2 Valores ExtremosProcedemos a identificar y dar tratamiento en la medidad de lo posible a los valores extremos que se identifiquen en el conjunto de datos, para esto se utilizará el diagrama de cajas para cada una de los atributos del dataset.
fig = plt.figure(figsize=(15,5)) fig.subplots_adjust(hspace=0.4, wspace=0.4) for i,atributo in enumerate(titanic_train[atributos_cuantitativos]): ax = fig.add_subplot(1, 4, i+1) sns.boxplot(data=titanic_train,y=atributo,ax=ax) plt.show()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
En función de lo observado se identifica que los datos de todas las variables se encuentran en una escala de valores adecuado, por lo que no se sugiere realizar un tratamiento de valores extremos.
titanic_train.to_csv('titanic_train_clean.csv') titanic_test.to_csv('titanic_test_clean.csv')
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
4. Análisis de los DatosDado que nuestro objetivo de análisis será generar un modelo que permita clasificar las personas que sobrevieron o no en función de sus atributos y con esto determinar si existían grupos de personas que tenían más probabilidades de sobrevivir que otros, procederemos a seleccionar los grupos de datos que se quieren para realizar el análisis y aplicaremos algunas pruebas estadísticas para comparar estos grupos. 4.1 Selección de los grupos de DatosSeleccionamos los grupos definidos inicialmente:* **Survived (1)**. Pasajero sobrevivió `sobrevivio_si`.* **Survived (0)**. Pasajero no sobrevivió `sobrevivio_no`.Además se discretizará el atributo edad en un nuevo atributo `age_range`
rangos = [0,16,40,60,np.inf] categorias = ['0-16', '16-40', '40-60', '+60'] titanic_train['Age_range'] = pd.cut(titanic_train['Age'], bins=ranges,labels=group_names) titanic_test['Age_range'] = pd.cut(titanic_test['Age'], bins=ranges,labels=group_names) sobrevivio_si=titanic_train[titanic_train['Survived']==1].copy() sobrevivio_no=titanic_train[titanic_train['Survived']==0].copy()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
**Análisis de Atributos Cualitativos**
atributos_cualitativos=['Age_range','Sex','Embarked','Pclass'] fig = plt.figure(figsize=(15,8)) fig.subplots_adjust(hspace=0.4, wspace=0.4) i=1 for atributo in atributos_cualitativos: ax = fig.add_subplot(2,4,i) sns.countplot(data=titanic_train,x=atributo, ax=ax) ax = fig.add_subplot(2,4,i+1) sns.countplot(data=titanic_train,x=atributo,hue='Survived',ax=ax,palette=hue_colors) i=i+2 plt.show() sns.set()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
* **Rango de Edad** `range_Age` En función del rango de edad podemos determinar que más del 50% de los pasajeros menores a 16 años sobrevivieron, en contraste con el resto de segmentos de edad, siendo las personas de más de 60 años las que en mayor proporción murieron. * **Sexo** `Sex` En función del sexo podemos determinar que en proporción las mujeres sobrevivieron mucho más que en los hombres. * **Puerto de Embarqued** `Embarked` En función del puerto de embarque podemos determinar que en proporción los pasajeros que embarcaron en el puerto **Cherbourg** sobrevivieron en mayor proporción que los embarcados en el resto de puertos. * **Calse** `Pclass` En función de la clase en el que viajaron los pasajeros podemos determinar que los pasajeros de primera clase sobrevivieron en mayor proporción, en contraste con el resto de clases, siendo los pasajeros de tercera clase los que en mayor proporción murieron. **Análisis de Atributos Cuantitativos**
sns.pairplot(titanic_train,hue='Survived',palette=hue_colors) plt.show()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
* **Edad** `Age` En función de la edad del pasajero se ratifica que a menor edad existieron mayor probabilidad de sobrevivir. * **Número de hermanos/cónyuge a bordo** `Sibsip` En función del número de hermanos/cónyuge a bordo podemos determinar que aquellos que tenían 1 tuvieron más probabilidad de sobrevivir. * **Número de padres/hijos a bordo** `Parch` En función del número de padres/hijos a bordo podemos determinar que aquellos que tenían 1 tuvieron más probabilidad de sobrevivir.* **Tarifa** `Fare` En función de la tarifa que pago el pasajero podemos determinar que los pasajeros cuyo boleto de mayor valor tuvieron mayor probabilidad de sobrevivir. 4.2 Normalidad y Homogeneidad de la Varianza de los Datos 4.2.1 NormalidadDeterminamos la normalidad de las variables dependientes para esto se utilizará el método visual q-q plot y el método estadístico Shapiro-Wilk test.
fig = plt.figure(figsize=(15,4)) fig.subplots_adjust(hspace=0.4, wspace=0.4) for i,variable in enumerate(atributos_cuantitativos): ax = fig.add_subplot(1, 4, i+1) ax.set_title(variable) qqplot(titanic_train[variable], line='s',ax=ax) # q-q plot stat, p = stats.shapiro(titanic_train[variable]) ax.set_xlabel('Statistics=%.2f, p=%.2E' % (stat, p)) plt.show()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Dado que para todas las variable en el test de `Shapiro-Wilk` se obtiene un *p-valor* **inferior** al nivel designificancia **α = 0.05**, entonces se determina que ninguna variable analizada sigue una distribución normal. 4.2.2 Homogeneidad de la Varianza de los DatosSe realizará el test de homogeneidad de la varianza para los atributos `Age` y `Fare` con realción a si sobrevivió o no el pasajero, para esto se utilizará la mediana como métrica dado que sus distribuciones no son normales.
statistic,pvalue = stats.levene(titanic_train.loc[sobrevivio_si.index,'Age'],titanic_train.loc[sobrevivio_no.index,'Age'], center='median') print('Age : Statistics=%.2f, p-value=%.2f' % (statistic,pvalue)) statistic,pvalue = stats.levene(titanic_train.loc[sobrevivio_si.index,'Fare'],titanic_train.loc[sobrevivio_no.index,'Fare'], center='median') print('Fare : Statistics=%.2f, p-value=%.2f' % (statistic,pvalue))
Age : Statistics=5.48, p-value=0.02 Fare : Statistics=45.10, p-value=0.00
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
En función de los test realizados determinamos que los atributos `Age` y `Fare` no tienen homogeneidad de la varianza en sus datos con relación a si el pasajero sobrevivió o no, por cuanto su estadístico *p-valor* es **inferior** al nivel de significancia **α <= 0.05**. 4.3 Pruebas EstadisticasEn función del objetivo del estudio procederemos a realizar pruebas estadísticas para comparar los grupos de datos definidos. 4.3.1 Test de Igualdad de MedianasDado que los atributos `Age` y `Fare` no siguen una distribución normal se utliza la prueba H de Kruskal-Wallis que prueba la hipótesis nula de que la mediana de la población de todos los grupos es igual, utilizamos el parámetro `equal_var=False` dado que las varianzas no son iguales en estos atributos para los grupos analizados.
statistic,pvalue = stats.kruskal(titanic_train.loc[sobrevivio_si.index,'Age'],titanic_train.loc[sobrevivio_no.index,'Age'], equal_var =False) print('Age : Statistics=%.2f, p-value=%.2f' % (statistic,pvalue)) statistic,pvalue = stats.kruskal(titanic_train.loc[sobrevivio_si.index,'Fare'],titanic_train.loc[sobrevivio_no.index,'Fare'], equal_var =False) print('Fare : Statistics=%.2f, p-value=%.2f' % (statistic,pvalue))
Age : Statistics=1.36, p-value=0.24 Fare : Statistics=93.28, p-value=0.00
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
En función del test realizado determinamos que el atributo `Age` tiene medianas iguales entre los dos grupos de análisis (sobrevivio_si, sobrevivio_no) por cuanto su estadístico *p-valor* es **superior** al nivel de significancia **α >= 0.05**, no así el atributo `Fare`. 4.3.2 Correlación de Variables
fig = plt.figure(figsize=(8,5)) sns.heatmap(titanic_train.corr(),cmap='Blues',annot=True,cbar=False) plt.title('Matriz de Correlación') plt.show()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Como se puede visualizar no existe alguna correlación fuerte entre las variables analizadas. 4.4 Regresión LogísticaProcederemos a realizar el modelo predictivo a través de una regresión logística, para esto realizaremos el proceso para codificar los atributos cuanlitativos a datos numéricos a través de `OneHotEncoder` y luego normalizaremos todas las variables a través de `StandardScaler`.
encoder = OneHotEncoder(drop='first') codificacion=encoder.fit_transform(titanic_train[['Pclass','Sex','Embarked']]).toarray() titanic_train_encoding = pd.DataFrame(codificacion,columns=np.hstack(['2','3','male','Q','S']))# encoder.categories_ titanic_train=titanic_train.join(titanic_train_encoding) titanic_train.drop(['Pclass','Sex','Embarked','Age_range'],axis=1,inplace=True) codificacion=encoder.fit_transform(titanic_test[['Pclass','Sex','Embarked']]).toarray() titanic_test_encoding = pd.DataFrame(codificacion,columns=np.hstack(['2','3','male','Q','S'])) #encoder.categories_ titanic_test=titanic_test.join(titanic_test_encoding) titanic_test.drop(['Pclass','Sex','Embarked','Age_range'],axis=1,inplace=True) survived=titanic_train['Survived'] titanic_train.drop(['Survived'],axis=1,inplace=True) titanic_train = pd.DataFrame(preprocessing.StandardScaler().fit_transform(titanic_train),columns=titanic_train.columns) titanic_test = pd.DataFrame(preprocessing.StandardScaler().fit_transform(titanic_test),columns=titanic_test.columns)
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Para determinar seleccionar los atributos que mayor aportación generen al modelo utilizaremos el proceso de eliminación de atributos recursivo `RFE (feature_selection)`.
logisticRegression = LogisticRegression() recursiveFeatureElimination = RFE(logisticRegression) recursiveFeatureElimination = recursiveFeatureElimination.fit(titanic_train, survived.values.ravel()) print(recursiveFeatureElimination.support_) print(recursiveFeatureElimination.ranking_) titanic_train=titanic_train.loc[:,recursiveFeatureElimination.support_].copy() titanic_test=titanic_test.loc[:,recursiveFeatureElimination.support_].copy() titanic_train.head()
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Como resultado de la selección de atributos, se seleccionaron: `Age` , `Pclass` y `Sex`.**Coeficientes y odds** Utilizaremos el modelo Logit para determinar los coeficientes del modelo.
logit_model=sm.Logit(survived,titanic_train) resultado=logit_model.fit() print(resultado.summary2()) print('Odds Ratios') print(np.exp(resultado.params))
Optimization terminated successfully. Current function value: 0.483180 Iterations 6 Results: Logit ================================================================= Model: Logit Pseudo R-squared: 0.274 Dependent Variable: Survived AIC: 869.0267 Date: 2021-06-05 18:38 BIC: 888.1961 No. Observations: 891 Log-Likelihood: -430.51 Df Model: 3 LL-Null: -593.33 Df Residuals: 887 LLR p-value: 2.8205e-70 Converged: 1.0000 Scale: 1.0000 No. Iterations: 6.0000 ------------------------------------------------------------------- Coef. Std.Err. z P>|z| [0.025 0.975] ------------------------------------------------------------------- Age -0.4131 0.0929 -4.4477 0.0000 -0.5951 -0.2311 2 -0.4623 0.1050 -4.4035 0.0000 -0.6681 -0.2565 3 -1.1064 0.1175 -9.4131 0.0000 -1.3368 -0.8760 male -1.2518 0.0908 -13.7811 0.0000 -1.4298 -1.0738 ================================================================= Odds Ratios Age 0.661592 2 0.629827 3 0.330750 male 0.285995 dtype: float64
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
**Interpretación de Odds Ratio**En función de los odds ratio del modelo de regresión logística, se puede concluir que:* **Age**. Por cada año de incremento en la edad, la probabilidad de sobrevivir es 0.66 veces menor.* **Pclass (2)**. La probabilidad de sobrevivir es 0.62 veces menor para la pasajeros de segunda clase, en relación con los pasajeros de las otras clases.* **Pclass (3)**. La probabilidad de sobrevivir es 0.33 veces menor para la pasajeros de tercera clase, en relación con los pasajeros de las otras clases.* **Sex (male)**. La probabilidad de sobrevivir es 0.28 veces menor para la pasajeros de sexo masculino, en relación con los pasajeros de sexo femenino.
X_train, X_test, y_train, y_test = train_test_split(titanic_train,survived,test_size=0.3,stratify=survived,random_state=24) logisticRegression = LogisticRegression() logisticRegression.fit(X_train, y_train) print('Accuracy of logistic regression classifier on train set: {:.2f} %'.format(logisticRegression.score(X_train, y_train)*100))
Accuracy of logistic regression classifier on train set: 79.61 %
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Como resultado del entrenamiento del modelo se obtuvo un accuracy en el conjunto de entrenamiento de **79.61%** 5. ResultadosCon el modelo entrenado determinamos:* El accuracy en el conjunto de test.* La matriz de confusión de los resultados del modelo.
print('Accuracy of logistic regression classifier on test set: {:.2f}%'.format(logisticRegression.score(X_test, y_test)*100)) matriz_confusion = confusion_matrix(y_test, logisticRegression.predict(X_test)) print('Matriz de Confusión:') sns.heatmap(matriz_confusion,annot=True,fmt="d",cbar=False,cmap="Blues") plt.xlabel('Observado') plt.ylabel('Estimado') plt.show()
Accuracy of logistic regression classifier on test set: 76.12% Matriz de Confusión:
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Como el conjunto de test se obtuvo un accuracy de **76.12%**, finalmente procedemos a calcular si sobrevivieron o no los pasajeros del conjunto `titanic_test`.
titanic_test_original['Survived_Prediction']=logisticRegression.predict(titanic_test) titanic_test_original
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
6. ConclusionesEn función de los resultados, podemos concluir que se obtiene un modelo relativamente bueno para clasificar si un pasajero sobrevivió o no, la precisión global del modelo es del **76.12%**. Esta precisión podría mejorarse utilizando modelos más avanzados bsados en árboles o redes neuronales.Además hemos determinado que los atributos más importantes a la hora de clasificar a los pasajeros si sobrevivieron o no son: `Age`, `Pclass` y `Fare`.Finalmente en función de los odds ratio del modelo de regresión logística, se puede concluir que:* **Age**. Por cada año de incremento en la edad, la probabilidad de sobrevivir es 0.66 veces menor.* **Pclass (2)**. La probabilidad de sobrevivir es 0.62 veces menor para la pasajeros de segunda clase, en relación con los pasajeros de las otras clases.* **Pclass (3)**. La probabilidad de sobrevivir es 0.33 veces menor para la pasajeros de tercera clase, en relación con los pasajeros de las otras clases.* **Sex (male)**. La probabilidad de sobrevivir es 0.28 veces menor para la pasajeros de sexo masculino, en relación con los pasajeros de sexo femenino.
pd.DataFrame({'CONTRIBUCIONES':['Investigación Previa','Redacción de las Respuestas','Desarrollo código'], 'FIRMA':['LP','LP','LP']})
_____no_output_____
MIT
src/Practica2_LimpiezaYAnalisisDatos_Titanic.ipynb
luispicouoc/LimpiezayAnalisisDatos
Flat Map Chains DemoExample demonstrateing how to extract protein chains from PDB entries. This example uses a flatMap function to transform a structure to its polymer chains. Imports
from pyspark.sql import SparkSession from mmtfPyspark.filters import PolymerComposition from mmtfPyspark.io import mmtfReader from mmtfPyspark.mappers import StructureToPolymerChains
_____no_output_____
Apache-2.0
demos/mappers/FlatMapChainsDemo.ipynb
sbliven/mmtf-pyspark
Configure Spark
spark = SparkSession.builder.appName("FlatMapChainsDemo").getOrCreate()
_____no_output_____
Apache-2.0
demos/mappers/FlatMapChainsDemo.ipynb
sbliven/mmtf-pyspark
Read in MMTF files
path = "../../resources/mmtf_reduced_sample/" pdb = mmtfReader.read_sequence_file(path)
_____no_output_____
Apache-2.0
demos/mappers/FlatMapChainsDemo.ipynb
sbliven/mmtf-pyspark
flat map structure to polymer chains, filter by polymer composition and count Supported polymer composition type:** polymerComposition.AMINO_ACIDS_20 **= ["ALA","ARG","ASN","ASP","CYS","GLN","GLU","GLY","HIS","ILE","LEU","LYS","MET","PHE","PRO","SER","THR","TRP","TYR","VAL"]** polymerComposition.AMINO_ACIDS_22 **= ["ALA","ARG","ASN","ASP","CYS","GLN","GLU","GLY","HIS","ILE","LEU","LYS","MET","PHE","PRO","SER","THR","TRP","TYR","VAL","SEC","PYL"]** polymerComposition.DNA_STD_NUCLEOTIDES **= ["DA","DC","DG","DT"]** polymerComposition.RNA_STD_NUCLEOTIDES **= ["A","C","G","U"]
count = pdb.flatMap(StructureToPolymerChains(False, True)) \ .filter(PolymerComposition(PolymerComposition.AMINO_ACIDS_20)) \ .count() print(f"Chains with standard amino acids: {count}")
Chains with standard amino acids: 8346
Apache-2.0
demos/mappers/FlatMapChainsDemo.ipynb
sbliven/mmtf-pyspark
Terminate Spark
spark.stop()
_____no_output_____
Apache-2.0
demos/mappers/FlatMapChainsDemo.ipynb
sbliven/mmtf-pyspark
Kubeflow pipelinesThis notebook goes through the steps of using Kubeflow pipelines using the Python3 interpreter (command-line) to preprocess, train, tune and deploy the babyweight model. 1. Start Hosted Pipelines and NotebookTo try out this notebook, first launch Kubeflow Hosted Pipelines and an AI Platform Notebooks instance.Follow the instructions in this [README.md](pipelines/README.md) file. 2. Install necessary packages
%pip install --quiet kfp python-dateutil --upgrade
_____no_output_____
Apache-2.0
courses/machine_learning/deepdive/06_structured/7_pipelines.ipynb
ranshiloni/training-data-analyst
Make sure to *restart the kernel* to pick up new packages (look for button in the ribbon of icons above this notebook) 3. Connect to the Hosted PipelinesVisit https://console.cloud.google.com/ai-platform/pipelines/clustersand get the hostname for your cluster. You can get it by clicking on the Settings icon.Alternately, click on the Open Pipelines Dashboard link and look at the URL.Change the settings in the following cell
# CHANGE THESE PIPELINES_HOST='447cdd24f70c9541-dot-us-central1.notebooks.googleusercontent.com' PROJECT='ai-analytics-solutions' BUCKET='ai-analytics-solutions-kfpdemo' import kfp client = kfp.Client(host=PIPELINES_HOST) #client.list_pipelines()
_____no_output_____
Apache-2.0
courses/machine_learning/deepdive/06_structured/7_pipelines.ipynb
ranshiloni/training-data-analyst
4. [Optional] Build Docker containersI have made my containers public, so you can simply use those.
%%bash cd pipelines/containers #bash build_all.sh
_____no_output_____
Apache-2.0
courses/machine_learning/deepdive/06_structured/7_pipelines.ipynb
ranshiloni/training-data-analyst
Check that the Docker images work properly ...
#!docker pull gcr.io/cloud-training-demos/babyweight-pipeline-bqtocsv:latest #!docker run -t gcr.io/cloud-training-demos/babyweight-pipeline-bqtocsv:latest --project $PROJECT --bucket $BUCKET --local
_____no_output_____
Apache-2.0
courses/machine_learning/deepdive/06_structured/7_pipelines.ipynb
ranshiloni/training-data-analyst
5. Upload and execute pipelineUpload to the Kubeflow pipeline cluster
from pipelines import mlp_babyweight pipeline = client.create_run_from_pipeline_func(mlp_babyweight.train_and_deploy, arguments={'project': PROJECT, 'bucket': BUCKET}) # Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License.
_____no_output_____
Apache-2.0
courses/machine_learning/deepdive/06_structured/7_pipelines.ipynb
ranshiloni/training-data-analyst
Analyze Worldwide Box Office Revenue with Plotly and Python Libraries
import numpy as np import pandas as pd pd.set_option('max_columns', None) import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline plt.style.use('ggplot') import datetime import lightgbm as lgb from scipy import stats from scipy.sparse import hstack, csr_matrix from sklearn.model_selection import train_test_split, KFold from wordcloud import WordCloud from collections import Counter from nltk.corpus import stopwords from nltk.util import ngrams from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer from sklearn.preprocessing import StandardScaler import nltk nltk.download('stopwords') stop = set(stopwords.words('english')) import os import plotly.offline as py py.init_notebook_mode(connected=True) import plotly.graph_objs as go import plotly.tools as tls import xgboost as xgb import lightgbm as lgb from sklearn import model_selection from sklearn.metrics import accuracy_score import json import ast from urllib.request import urlopen from PIL import Image from sklearn.preprocessing import LabelEncoder import time from sklearn.metrics import mean_squared_error from sklearn.linear_model import LinearRegression from sklearn import linear_model
/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead. import pandas.util.testing as tm
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Data Loading and Exploration
train = pd.read_csv('train.csv') test = pd.read_csv('test.csv') train.head()
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Visualizing the Target Distribution
fig, ax = plt.subplots(figsize = (16, 6)) plt.subplot(1, 2, 1) plt.hist(train['revenue']); plt.title('Distribution of revenue'); plt.subplot(1, 2, 2) plt.hist(np.log1p(train['revenue'])); plt.title('Distribution of log of revenue'); train['log_revenue'] = np.log1p(train['revenue'])
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Relationship between Film Revenue and Budget
fig, ax = plt.subplots(figsize = (16, 6)) plt.subplot(1, 2, 1) plt.hist(train['budget']); plt.title('Distribution of budget'); plt.subplot(1, 2, 2) plt.hist(np.log1p(train['budget'])); plt.title('Distribution of log of budget'); plt.figure(figsize=(16, 8)) plt.subplot(1, 2, 1) plt.scatter(train['budget'], train['revenue']) plt.title('Revenue vs budget'); plt.subplot(1, 2, 2) plt.scatter(np.log1p(train['budget']), train['log_revenue']) plt.title('Log Revenue vs log budget'); train['log_budget'] = np.log1p(train['budget']) test['log_budget'] = np.log1p(test['budget'])
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Does having an Official Homepage Affect Revenue?
train['homepage'].value_counts().head(10) train['has_homepage'] = 0 train.loc[train['homepage'].isnull() == False, 'has_homepage'] = 1 test['has_homepage'] = 0 test.loc[test['homepage'].isnull() == False, 'has_homepage'] = 1 sns.catplot(x='has_homepage', y='revenue', data=train); plt.title('Revenue for film with and without homepage');
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Distribution of Languages in Film
plt.figure(figsize=(16, 8)) plt.subplot(1, 2, 1) sns.boxplot(x='original_language', y='revenue', data=train.loc[train['original_language'].isin(train['original_language'].value_counts().head(10).index)]); plt.title('Mean revenue per language'); plt.subplot(1, 2, 2) sns.boxplot(x='original_language', y='log_revenue', data=train.loc[train['original_language'].isin(train['original_language'].value_counts().head(10).index)]); plt.title('Mean log revenue per language');
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Frequent Words in Film Titles and Discriptions
plt.figure(figsize = (12, 12)) text = ' '.join(train['original_title'].values) wordcloud = WordCloud(max_font_size=None, background_color='white', width=1200, height=1000).generate(text) plt.imshow(wordcloud) plt.title('Top words in titles') plt.axis("off") plt.show() plt.figure(figsize = (12, 12)) text = ' '.join(train['overview'].fillna('').values) wordcloud = WordCloud(max_font_size=None, background_color='white', width=1200, height=1000).generate(text) plt.imshow(wordcloud) plt.title('Top words in overview') plt.axis("off") plt.show()
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Do Film Descriptions Impact Revenue?
import eli5 vectorizer = TfidfVectorizer( sublinear_tf=True, analyzer='word', token_pattern=r'\w{1,}', ngram_range=(1, 2), min_df=5) overview_text = vectorizer.fit_transform(train['overview'].fillna('')) linreg = LinearRegression() linreg.fit(overview_text, train['log_revenue']) eli5.show_weights(linreg, vec=vectorizer, top=20, feature_filter=lambda x: x != '<BIAS>') print('Target value:', train['log_revenue'][1000]) eli5.show_prediction(linreg, doc=train['overview'].values[1000], vec=vectorizer)
Target value: 16.44583954907521
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Analyzing Movie Release Dates
test.loc[test['release_date'].isnull()==False,'release_date'].head()
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Preprocessing Features
def fix_date(x): year = x.split('/')[2] if int(year)<=19: return x[:-2] + '20' + year else: return x[:-2] + '19' + year test.loc[test['release_date'].isnull() == True].head() test.loc[test['release_date'].isnull() == True, 'release_date'] = '05/01/00' train['release_date'] = train['release_date'].apply(lambda x: fix_date(x)) test['release_date'] = test['release_date'].apply(lambda x: fix_date(x))
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Creating Features Based on Release Date
train['release_date'] = pd.to_datetime(train['release_date']) test['release_date'] = pd.to_datetime(test['release_date']) def process_date(df): date_parts = ['year','weekday','month','weekofyear','day','quarter'] for part in date_parts: part_col = 'release_date' + '_' + part df[part_col] = getattr(df['release_date'].dt,part).astype(int) return df train = process_date(train) test= process_date(test)
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Using Plotly to Visualize the Number of Films Per Year
d1=train['release_date_year'].value_counts().sort_index() d2=test['release_date_year'].value_counts().sort_index() import plotly.offline as py py.init_notebook_mode(connected=True) import plotly.graph_objs as go data = [go.Scatter(x=d1.index, y =d1.values, name='train'), go.Scatter(x=d2.index,y=d2.values,name='test')] layout = go.Layout(dict(title= 'Number of flims per year', xaxis = dict(title = 'Year'), yaxis=dict(title='Count'), ),legend= dict(orientation='v')) py.iplot(dict(data=data,layout=layout))
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Number of Films and Revenue Per Year
#d1 = train['release_date_year'].value.counts().sort_index() d1=train['release_date_year'].value_counts().sort_index() d2 = train.groupby(['release_date_year'])['revenue'].sum() data = [go.Scatter (x=d1.index,y=d1.values,name='film count'), go.Scatter(x=d2.index, y=d2.values,name='total revenue',yaxis='y2')] layout = go.Layout(dict(title = 'Number of flims and revenue per year', xaxis = dict(title = 'Year'), yaxis = dict(title = 'count'), yaxis2=dict(title='total revenue',overlaying='y', side='right')), legend=dict(orientation='v')) py.iplot(dict(data=data, layout=layout)) #d1 = train['release_date_year'].value.counts().sort_index() d1=train['release_date_year'].value_counts().sort_index() d2 = train.groupby(['release_date_year'])['revenue'].mean() data = [go.Scatter (x=d1.index,y=d1.values,name='film count'), go.Scatter(x=d2.index, y=d2.values,name='average revenue',yaxis='y2')] layout = go.Layout(dict(title = 'Number of flims and revenue per year', xaxis = dict(title = 'Year'), yaxis = dict(title = 'count'), yaxis2=dict(title='average revenue',overlaying='y', side='right')), legend=dict(orientation='v')) py.iplot(dict(data=data, layout=layout))
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Do Release Days Impact Revenue?
sns.catplot(x='release_date_weekday', y='revenue',data=train); plt.title('revenue of dif days of the week')
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Relationship between Runtime and Revenue
sns.distplot(train['runtime'].fillna(0)/60,bins=(40),kde=False); plt.title('distribution of flims in hrs') sns.scatterplot(train['runtime'].fillna(0)/60, train['revenue']) plt.title('runtime vs revenue')
_____no_output_____
MIT
BOX_OFFICE_ANALYSIS_WITH_PLOTLY_AND_PY.ipynb
itsdharmil/box-office-analysis-with-plotly-and-python
Large File Input Source: [https://github.com/d-insight/code-bank.git](https://github.com/d-insight/code-bank.git) License: [MIT License](https://opensource.org/licenses/MIT). See open source [license](LICENSE) in the Code Bank repository. --- Import libraries
import numpy as np import pandas as pd from pathlib import Path import csv from pprint import pprint import sqlite3 from sqlalchemy import create_engine
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Set data directory
DIR = 'data' FILE = '/yellow_tripdata_2016-03.csv' csv_file = '{}{}'.format(DIR, FILE) print('File directory: {}'.format(csv_file))
File directory: data/yellow_tripdata_2016-03.csv
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
How large is the dataset on disk?
size = Path(csv_file).stat().st_size f'{size:,} bytes'
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
How many rows of data?
with open(csv_file) as f: row_count = sum(1 for row in f) # generator expression f'{row_count:,} rows'
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Inspect Raw Data
with open(csv_file) as f: for i, row in enumerate(f): pprint(row) if i == 3: break
'VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,pickup_longitude,pickup_latitude,RatecodeID,store_and_fwd_flag,dropoff_longitude,dropoff_latitude,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount\n' ('1,2016-03-01 00:00:00,2016-03-01 ' '00:07:55,1,2.50,-73.97674560546875,40.765151977539062,1,N,-74.004264831542969,40.746128082275391,1,9,0.5,0.5,2.05,0,0.3,12.35\n') ('1,2016-03-01 00:00:00,2016-03-01 ' '00:11:06,1,2.90,-73.983482360839844,40.767925262451172,1,N,-74.005943298339844,40.733165740966797,1,11,0.5,0.5,3.05,0,0.3,15.35\n') ('2,2016-03-01 00:00:00,2016-03-01 ' '00:31:06,2,19.98,-73.782020568847656,40.644809722900391,1,N,-73.974540710449219,40.675769805908203,1,54.5,0.5,0.5,8,0,0.3,63.8\n')
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Cleaner view
with open(csv_file) as f: csv_dict = csv.DictReader(f) for i, row in enumerate(csv_dict): pprint(row) if i ==3: break
{'RatecodeID': '1', 'VendorID': '1', 'dropoff_latitude': '40.746128082275391', 'dropoff_longitude': '-74.004264831542969', 'extra': '0.5', 'fare_amount': '9', 'improvement_surcharge': '0.3', 'mta_tax': '0.5', 'passenger_count': '1', 'payment_type': '1', 'pickup_latitude': '40.765151977539062', 'pickup_longitude': '-73.97674560546875', 'store_and_fwd_flag': 'N', 'tip_amount': '2.05', 'tolls_amount': '0', 'total_amount': '12.35', 'tpep_dropoff_datetime': '2016-03-01 00:07:55', 'tpep_pickup_datetime': '2016-03-01 00:00:00', 'trip_distance': '2.50'} {'RatecodeID': '1', 'VendorID': '1', 'dropoff_latitude': '40.733165740966797', 'dropoff_longitude': '-74.005943298339844', 'extra': '0.5', 'fare_amount': '11', 'improvement_surcharge': '0.3', 'mta_tax': '0.5', 'passenger_count': '1', 'payment_type': '1', 'pickup_latitude': '40.767925262451172', 'pickup_longitude': '-73.983482360839844', 'store_and_fwd_flag': 'N', 'tip_amount': '3.05', 'tolls_amount': '0', 'total_amount': '15.35', 'tpep_dropoff_datetime': '2016-03-01 00:11:06', 'tpep_pickup_datetime': '2016-03-01 00:00:00', 'trip_distance': '2.90'} {'RatecodeID': '1', 'VendorID': '2', 'dropoff_latitude': '40.675769805908203', 'dropoff_longitude': '-73.974540710449219', 'extra': '0.5', 'fare_amount': '54.5', 'improvement_surcharge': '0.3', 'mta_tax': '0.5', 'passenger_count': '2', 'payment_type': '1', 'pickup_latitude': '40.644809722900391', 'pickup_longitude': '-73.782020568847656', 'store_and_fwd_flag': 'N', 'tip_amount': '8', 'tolls_amount': '0', 'total_amount': '63.8', 'tpep_dropoff_datetime': '2016-03-01 00:31:06', 'tpep_pickup_datetime': '2016-03-01 00:00:00', 'trip_distance': '19.98'} {'RatecodeID': '1', 'VendorID': '2', 'dropoff_latitude': '40.757766723632812', 'dropoff_longitude': '-73.969650268554688', 'extra': '0', 'fare_amount': '31.5', 'improvement_surcharge': '0.3', 'mta_tax': '0.5', 'passenger_count': '3', 'payment_type': '1', 'pickup_latitude': '40.769813537597656', 'pickup_longitude': '-73.863418579101562', 'store_and_fwd_flag': 'N', 'tip_amount': '3.78', 'tolls_amount': '5.54', 'total_amount': '41.62', 'tpep_dropoff_datetime': '2016-03-01 00:00:00', 'tpep_pickup_datetime': '2016-03-01 00:00:00', 'trip_distance': '10.78'}
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Import few rows using pandas
print(pd.read_csv(csv_file, nrows=2))
VendorID tpep_pickup_datetime tpep_dropoff_datetime passenger_count \ 0 1 2016-03-01 00:00:00 2016-03-01 00:07:55 1 1 1 2016-03-01 00:00:00 2016-03-01 00:11:06 1 trip_distance pickup_longitude pickup_latitude RatecodeID \ 0 2.5 -73.976746 40.765152 1 1 2.9 -73.983482 40.767925 1 store_and_fwd_flag dropoff_longitude dropoff_latitude payment_type \ 0 N -74.004265 40.746128 1 1 N -74.005943 40.733166 1 fare_amount extra mta_tax tip_amount tolls_amount \ 0 9 0.5 0.5 2.05 0 1 11 0.5 0.5 3.05 0 improvement_surcharge total_amount 0 0.3 12.35 1 0.3 15.35
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Loaded succesfully! Calculating Size Let’s load the first 10,000 lines into pandas and measure the amount of memory being used. Then we can calculate the total amount of memory needed to load the complete file
nrows = 10_000 MB = 2**20 # 1 MB = 2**20 bytes = 1,048,576 bytes df = pd.read_csv(csv_file, nrows=nrows) df_mb = df.memory_usage(deep=True).sum() / MB df_mb # how much memory the DataFrame is consuming in MB df_mb * (row_count / nrows) # total memory consumption for the whole data file. ~4GB
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Import Standard way -> Memory Error!
#df = pd.read_csv(file) df.shape
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
#df.info()
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Solution A: Chunking!
chunk_size=50000 batch_no=1 for chunk in pd.read_csv(csv_file,chunksize=chunk_size): chunk.to_csv(DIR+'chunk'+str(batch_no)+'.csv',index=False) batch_no+=1
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Importing a single chunk file into pandas dataframe:
DIR df1 = pd.read_csv(DIR+'chunk2.csv') df1.head()
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Solution B: SQL!1. Create a Connector to a Database2. Build the Database (load CSV File) by Chunking3. Construct Pandas DF from Database using SQL query
# Create a Connector to a Database (creates it in Memory - not an SQL db) csv_database = create_engine('sqlite:///csv_database.db') # Build the Database (load CSV File) by Chunking chunk_size=10000 i=0 j=0 for df in pd.read_csv(csv_file, chunksize=chunk_size, iterator=True): df = df.rename(columns= {c: c.replace(' ','') for c in df.columns}) # remove spaces in col names is important to make SQL run well df.index += j # Put all data in data_sql Table (temp table), using engine to fire it in background. Temp db sitting in Memory df.to_sql('data_sql', csv_database, if_exists = 'append') j = df.index[-1]+1 print('| index: {}'.format(j)) df2 = pd.read_sql_query('SELECT * FROM data_sql WHERE VendorID=1 AND trip_distance=2.90', csv_database) df2 df2.columns
_____no_output_____
MIT
_development/tutorials/automate-excel/4-large-file.ipynb
dsfm-org/code-bank
Decoding sensor space data with generalization across time and conditionsThis example runs the analysis described in [1]_. It illustrates how one canfit a linear classifier to identify a discriminatory topography at a given timeinstant and subsequently assess whether this linear model can accuratelypredict all of the time samples of a second set of conditions.References----------.. [1] King & Dehaene (2014) 'Characterizing the dynamics of mental representations: the Temporal Generalization method', Trends In Cognitive Sciences, 18(4), 203-210. doi: 10.1016/j.tics.2014.01.002.
# Authors: Jean-Remi King <[email protected]> # Alexandre Gramfort <[email protected]> # Denis Engemann <[email protected]> # # License: BSD (3-clause) import matplotlib.pyplot as plt from sklearn.pipeline import make_pipeline from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LogisticRegression import mne from mne.datasets import sample from mne.decoding import GeneralizingEstimator print(__doc__) # Preprocess data data_path = sample.data_path() # Load and filter data, set up epochs raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' events_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif' raw = mne.io.read_raw_fif(raw_fname, preload=True) picks = mne.pick_types(raw.info, meg=True, exclude='bads') # Pick MEG channels raw.filter(1., 30., fir_design='firwin') # Band pass filtering signals events = mne.read_events(events_fname) event_id = {'Auditory/Left': 1, 'Auditory/Right': 2, 'Visual/Left': 3, 'Visual/Right': 4} tmin = -0.050 tmax = 0.400 decim = 2 # decimate to make the example faster to run epochs = mne.Epochs(raw, events, event_id=event_id, tmin=tmin, tmax=tmax, proj=True, picks=picks, baseline=None, preload=True, reject=dict(mag=5e-12), decim=decim) # We will train the classifier on all left visual vs auditory trials # and test on all right visual vs auditory trials. clf = make_pipeline(StandardScaler(), LogisticRegression()) time_gen = GeneralizingEstimator(clf, scoring='roc_auc', n_jobs=1) # Fit classifiers on the epochs where the stimulus was presented to the left. # Note that the experimental condition y indicates auditory or visual time_gen.fit(X=epochs['Left'].get_data(), y=epochs['Left'].events[:, 2] > 2) # Score on the epochs where the stimulus was presented to the right. scores = time_gen.score(X=epochs['Right'].get_data(), y=epochs['Right'].events[:, 2] > 2) # Plot fig, ax = plt.subplots(1) im = ax.matshow(scores, vmin=0, vmax=1., cmap='RdBu_r', origin='lower', extent=epochs.times[[0, -1, 0, -1]]) ax.axhline(0., color='k') ax.axvline(0., color='k') ax.xaxis.set_ticks_position('bottom') ax.set_xlabel('Testing Time (s)') ax.set_ylabel('Training Time (s)') ax.set_title('Generalization across time and condition') plt.colorbar(im, ax=ax) plt.show()
_____no_output_____
BSD-3-Clause
0.16/_downloads/plot_decoding_time_generalization_conditions.ipynb
drammock/mne-tools.github.io
Copyright 2019 The TensorFlow Authors.
#@title Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License.
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Σύνοψη Keras Άνοιγμα στο TensorFlow.org Εκτέλεση στο Google Colab Προβολή πηγαίου στο GitHub Λήψη "σημειωματάριου" Note: Η κοινότητα του TensorFlow έχει μεταφράσει αυτά τα έγγραφα. Καθότι οι μεταφράσεις αυτές αποτελούν την καλύτερη δυνατή προσπάθεια , δεν υπάρχει εγγύηση ότι θα παραμείνουν ενημερωμένες σε σχέση με τα [επίσημα Αγγλικά έγγραφα](https://www.tensorflow.org/?hl=en).Αν έχετε υποδείξεις για βελτίωση των αρχείων αυτών , δημιουργήστε ένα pull request στο [tensorflow/docs](https://github.com/tensorflow/docs) GitHub repository . Για να συμμετέχετε στη σύνταξη ή στην αναθεώρηση των μεταφράσεων της κοινότητας , επικοινωνήστε με το [[email protected] list](https://groups.google.com/a/tensorflow.org/forum/!forum/docs). Ο οδήγός αυτός προσφέρει τα βασικά ώστε να ξεκινήσετε να χρησιμοποιείτε το Keras. Η διάρκεια ανάγνωσης του είναι περίπου 10 λεπτά. Εισαγωγή tf.keras`tf.keras` . Πρόκειται για την υλοποίησης Διασύνδεσης Προγραμματισμού Εφαρμογών (API) του Keras. Είναι ένα API υψηλού επιπέδου που μπορεί να δημιουργήσει και να εκπαιδεύσει μοντέλα τα οποία θα υποστηρίζουν άμεσα τις υπόλοιπες λειτουργίες του TensorFlow , όπως η ["ενθουσιώδης" εκτέλεση](https://www.tensorflow.org/guide/eager) , `tf.data` αγωγοί , και [Εκτιμητές](https://www.tensorflow.org/guide/estimator)Το `tf.keras` καθιστά το TensorFlow ευκολότερο στη χρήση , χωρίς να θυσιάζει σε προσαρμοστικότητα και απόδοσηΓια να ξεκινήσετε , εισάγετε το `tf.keras` ως μέρος του προγράμματος TensorFlowσας :
from __future__ import absolute_import, division, print_function, unicode_literals try: # %tensorflow_version only exists in Colab. %tensorflow_version 2.x except Exception: pass import tensorflow as tf from tensorflow import keras
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Το tf.keras μπορέι να τρέξει οποιοδήποτε κομμάτι συμβατού κώδικα Keras , ωστόσο να έχετε υπόψιν σας τα εξής : * Η έκδοση `tf.keras` της τελευταίας έκδοσης του TensorFlow μπορεί να μην ταυτίζεται με την τελευταία έκδοση `keras` από το PyPI. Ελέγξτε το `tf.keras.__version__.`* Όταν [αποθηκεύετε τα βάρη ενός μοντέλου](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/keras/save_and_serialize.ipynb) το `tf.keras` θα προεπιλέγει την [μορφοποίηση σημείων ελέγχου](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/checkpoint.ipynb). Θέτοντας `save_format='h5'` χρησιμοποιείται η μορφοποίηση HDF5 (εναλλακτικά, ορίστε την επέκταση του αρχείου σε `.h5`) Δημιουργία απλού μοντέλου Σειριακό μοντέλοΣτο Keras , συναθροίζοντας στρώματα(layers) δημιουργούνται τα *μοντελα (models)*. Ένα μοντέλο είναι (συνήθως) ένα γράφημα στρωμάτων. Ο πιο συνηθισμένος τύπος μοντέλου είναι η στοίβα (stack) στρωμάτων : το `tf.keras.Sequential` μοντέλοΓια την κατασκευή ενός απλού, πλήρως συνδεδεμένου (νευρωνικού) δικτύου (για παράδειγμα : πολυεπίπεδο perceptron):
from tensorflow.keras import layers model = tf.keras.Sequential() # Adds a densely-connected layer with 64 units to the model: model.add(layers.Dense(64, activation='relu')) # Add another: model.add(layers.Dense(64, activation='relu')) # Add a softmax layer with 10 output units: model.add(layers.Dense(10, activation='softmax'))
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Μπορείτε να βρείτε ένα ολοκληρωμένο και σύντομο παράδειγμα για το πώς χρησιμοποιούνται τα σειριακά μοντέλα [εδώ](https://www.tensorflow.org/tutorials/quickstart/beginner)Για να μάθετε να δημιουργείτε πιο προχωρημένα μοντέλα από τα σειριακά , δέιτε τα εξής :* [Οδηγός για το Keras functional API link text](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/keras/functional.ipynb)*[Οδηγός για τη σύνθεση επιπέδων και μοντέλων από το μηδέν μέσω της ενθυλάκωσης](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/keras/custom_layers_and_models.ipynb) Διαμόρφωση των επιπέδωνΥπάρχουν πολλά επίπεδα `tf.keras.layers` διαθέσιμα. Τα περισσότερα από αυτά έχουν συνήθη ορίσματα στον κατασκευαστή : * `activation` : Θέτει τη συνάρτηση ενεργοποίησης το επίπεδο. Η παράμετρος αυτή διασαφηνίζεται από το όνομα μίας προεγκατεστημένης συνάρτησης , διαφορετικά ως ένα προς κλήση αντικείμενο. Ως προεπιλογή , δεν εφαρμόζεται activation* `kernel_initializer` και `bias_initializer` : Τα σχέδια αρχικοποίησης που δημιουργούν τα βάρη του επιπέδου (kernel και bias). Η παράμετρος αυτή είναι είτε όνομα είτε αντικείμενο που μπορεί να κληθεί . Αρχικοποιείται , ως προεπιλογή , στον `"Glorot uniform"` αρχικοποιητή.* `kernel_regularizer` και `bias_regularizer` : Τα σχέδια ρύθμισης που εφαρμόζουν τα βάρη του επιπέδου (kernel και bias), όπως για παράδειγμα οι L1 orL2 regularization (L1 ή L2 ρυθμίσεις). Ως προεπιλογή , δεν εφαρμόζεται regularizationΟ ακόλουθος κώδικας δίνει υπόσταση στα `tf.keras.layers.Dense` επίπεδα με τη χρήση ορισμάτων σε κατασκευαστές :
# Create a sigmoid layer: layers.Dense(64, activation='sigmoid') # Or: layers.Dense(64, activation=tf.keras.activations.sigmoid) # A linear layer with L1 regularization of factor 0.01 applied to the kernel matrix: layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01)) # A linear layer with L2 regularization of factor 0.01 applied to the bias vector: layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01)) # A linear layer with a kernel initialized to a random orthogonal matrix: layers.Dense(64, kernel_initializer='orthogonal') # A linear layer with a bias vector initialized to 2.0s: layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Μάθηση και αξιολόγηση Στήνοντας την μάθησηΑφότου έχει κατασκευαστεί το μοντέλο, ορίστε την διαδικασία μάθησης καλώντας την μέθοδο `compile`:
model = tf.keras.Sequential([ # Adds a densely-connected layer with 64 units to the model: layers.Dense(64, activation='relu', input_shape=(32,)), # Add another: layers.Dense(64, activation='relu'), # Add a softmax layer with 10 output units: layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='categorical_crossentropy', metrics=['accuracy'])
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Η μέθοδος `tf.keras.Model.compile` δέχεται 3 σημαντικά ορίσματα : * `optimizer` : Το αντικείμενο αυτό προσδιορίζει την διαδικασία μάθησης. Περάστε στιγμιότυπα βελτιστοποίησης (optimizer instances) από το άρθρωμα (module) `tf.keras.optimizers` , όπως `tf.keras.optimizers.Adam` ή `tf.keras.optimizers.SGD`. Αν θέλετε να χρησιμοποιήσετε τις προεπιλεγμένες παραμέτρους , μπορείτε να προσδιορίσετε βελτιστοποιητές μέσω συμβολοσειρών(strings) , όπως `adam` ή `sgd`.* `loss` : Η συνάρτηση που πρέπει να ελαχιστοποιείται κατά τη βελτιστοποίηση. Συνήθεις επιλογές είναι η μέση τετραγωνική απόκλιση(mse) ,`categorical_crossentropy`, και `binary_crossentropy`. Oι loss functions προσδιορίζονται μέσω του ονόματος ή παιρνώντας ένα αντικείμενο από το άρθρωμα `tf.keras.losses`.* `metrics`: Χρησιμοποιείται για την παρακολούθηση της διαδικασίας. Πρόκειται για συμβολοσειρές ή για προς κλήση αντικείμενα από το άρθρωμα `tf.keras.metrics`* Επιπρόσθετα , για να βεβαιωθείτε ότι το μοντέλο μαθαίνει και αξιολογεί eagerly("ενθουσιωδώς"), μπορείτε να θέσετε `run_eagerly=True` ως παράμετρο κατά την μεταγλώττισηΟ ακόλουθος κώδικας υλοποιεί μερικά παραδείγματα παραμετροποίησης μοντέλου για μάθηση :
# Configure a model for mean-squared error regression. model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='mse', # mean squared error metrics=['mae']) # mean absolute error # Configure a model for categorical classification. model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Μάθηση από NumPy δεδομέναΣε μικρό όγκο δεδομένων,συνιστάται η χρήση των in-memory πινάκων [NumPy](https://numpy.org/) για την μάθηση και την αξιολόγηση ενός μοντέλου. Το μοντέλο "ταιριάζει" στα δεδομένα εκμάθησης μέσω της μεθόδου `fit` :
import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Η μέθοδος `tf.keras.Model.fit` δέχεται 3 ορίσματα : * `epochs` : Η μάθηση οργανώνεται σε *εποχές* (epochs). *Εποχή* είναι μία επανάληψη σε όλο τον όγκο των δεδομένων εισόδου(αυτό γίνεται πρώτα σε μικρότερες "δεσμίδες" δεδομένων)* `batch_size` : Όταν περνάνε τα δεδομένα NumPy , το μοντέλο τα τεμαχίζει σε (μικρότερες) "δεσμίδες" και εκτελεί επαναλήψεις πάνω σε αυτές κατά την εκμάθηση.* `validation_data` : Όταν δημιουργείτε ένα πρωτότυπο ενός μοντέλους , θα ήταν επιθυμητό να παρακολουθείτε με ευκολία την απόδοσή του σε μερικά δεδομένα επαλήθευσης (validation data). Περνώντας αυτό το όρισμα -μία πλειάδα εισόδων και "ετικετών"- επιτρέπετε στο μοντέλο να δείχνει την απώλεια και τις μετρήσεις σε "συμπερασματική" λειτουργία (inference mode) για τα εισαγώμενα δεδομένα, στο τέλος κάθε *εποχής*Ακολουθεί παράδειγμα με την χρήση της `validation_data` :
import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Μάθηση από σύνολα δεδομένων(datasets) tf.dataΧρησιμοποιείστε τo [Datasets API](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/data.ipynb) για να κλιμακώσετε μεγάλα σύνολα δεδομένων ή μάθηση σε πολλές συσκευές. Περάστε ένα `tf.data.Dataset` στιγμιότυπο στην μέθοδο `fit` :
# Instantiates a toy dataset instance: dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Από τη στιγμή που το `Dataset` παράγει "δεσμίδες" δεδομένων , αυτό το απόσπασμα δεν απαίτει το `batch_size`. Τα σύνολα δεδομένων μπορούν να χρησιμοποιηθούν και για επιβεβαίωση :
dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Αξιολόγηση και πρόβλεψηΟι `tf.keras.Model.evaluate` και `tf.keras.Model.predict` μέθοδοι μπορούν να χρησιμοποιήσουν δεδομένα NumPy και ένα `tf.data.Dataset`.Ακολουθεί ο τρόπος αξιολόγησης "συμπερασματικής" λειτουργίας των απωλειών και των μετρήσεων για τα παρεχόμενα δεδομένα :
# With Numpy arrays data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) # With a Dataset dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.evaluate(dataset)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Με αυτό το απόσπασμα μπορείτε να προβλέψετε την έξοδο του τελευταίου επιπέδου σε inference για τα παρεχόμενα δεδομένα , ως έναν πίνακα NumPy :
result = model.predict(data, batch_size=32) print(result.shape)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Για έναν ολοκληρωμένο οδηγό στην εκμάθηση και την αξιολόγηση , ο οποίος περιλαμβάνει και οδηγίες για συγγραφή προσαρμοσμένων loops μαθήσεως από το μηδέν , δείτε τον οδηγό [αυτό](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/keras/train_and_evaluate.ipynb). Δημιουργία σύνθετων μοντέλων To Functional APIΤο μοντέλο `tf.keras.Sequential` είναι μία απλή στοίβα επιπέδων η οποία δεν μπορεί να εκπροσωπήσει αυθαίρετα μοντέλα .Με τη χρήση του [Keras functional API](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/keras/functional.ipynbscrollTo=vCMYwDIE9dTT) μπορείτε να φτιάξετε σύνθετες τοπολογίες μοντέλων όπως :* Μοντέλα πολλαπλών εισόδων,* Μοντέλα πολλαπλών εξόδων,* Μοντέλα με κοινόχρηστα επίπεδα (το ίδιο επίπεδο να καλείται πολλαπλές φορές),* Μοντέλα με μη σειριακή ροή δεδομένων (π.χ residual connections)H δημιουργία μοντέλων με το functional API ακολουθεί το εξής : 1. Ένα στιγμιότυπο ενός επιπέδου καλείται και επιστρέφει έναν τανυστή(tensor).2. Τανυστές εισόδου και εξόδου χρησιμοποιούνται για να ορίσουν μία κατάσταση της `tf.keras.Model`.3. Το μοντέλο μαθαίνει κατά τον ίδιο τρόπο με το `Σειριακό` μοντέλο.Το ακόλουθο παράδειγμα χρησιμοποιεί το functional API για να φτιάξει ένα απλό, πλήρως συνδεδεμένο (νευρωνικό) δίκτυο :
inputs = tf.keras.Input(shape=(32,)) # Returns an input placeholder # A layer instance is callable on a tensor, and returns a tensor. x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Δώστε υπόσταση στο μοντέλο με είσοδο και έξοδο:
model = tf.keras.Model(inputs=inputs, outputs=predictions) # The compile step specifies the training configuration. model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) # Trains for 5 epochs model.fit(data, labels, batch_size=32, epochs=5)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Υποκατηγοριοποίηση στα μοντέλαΦτιάξτε ένα πλήρως παραμετροποιήσιμο μοντέλο υποκατηγοριοποιώντας την `tf.keras.Model` και ορίζοντας το δικό σας "προς τα εμπρος πέρασμα"(forward pass,κοινώς διαδικασία υπολογισμού η οποία ξεκινάει από το 1ο προς το τελευταίο επίπεδο). Κατασκευάστε επίπεδα στην μέθοδο `__init__` και θέστε τα ως ιδιότητες της κλάσης . Ορίστε έπειτα το "προς τα εμπρος πέρασμα"(forward pass)στην μέθοδο `call`.Η υποκατηγοριοποίηση στα μοντέλα είναι ιδιαίτερα χρήσιμη όταν η ["ενθουσιώδης" εκτέλεση](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/guide/eager.ipynb) είναι ενεργοποιημένη ,καθώς επιτρέπει το "προς τα εμπρος πέρασμα"(forward pass) να εγγράφεται αναγκαστικά.Σημείωση: αν το μοντέλο σας χρειάζεται να τρέχει *πάντα* αναγκαστικά, μπορείτε να θέσετε `dynamic=True` όταν καλείται ο `super` κατασκευαστής.> Σημείο κλειδί : Χρησιμοποιήστε το σωστό , ανάλογα με την δουλειά , API . Παρόλο που η χρήση της υποκατηγοριοποίηση προσφέρει ευελιξία , κοστίζει σε πολυπλοκότητα και σε μεγαλύτερα περιθώρια για σφάλματα χρήστη. Αν είναι εφικ΄το , προτιμήστε το functional API. Το ακόλουθο παράδειγμα δείχνει μια υποκλάση `tf.keras.Model` που χρησιμοποιεί "προς τα εμπρός πέρασμα" το οποίο δεν χρειάζεται να εκτελείται αναγκαστικά:
class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes # Define your layers here. self.dense_1 = layers.Dense(32, activation='relu') self.dense_2 = layers.Dense(num_classes, activation='sigmoid') def call(self, inputs): # Define your forward pass here, # using layers you previously defined (in `__init__`). x = self.dense_1(inputs) return self.dense_2(x)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Η νέα κλάση model λαμβάνει υπόσταση :
model = MyModel(num_classes=10) # The compile step specifies the training configuration. model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) # Trains for 5 epochs. model.fit(data, labels, batch_size=32, epochs=5)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Παραμετροποιήσιμα επίπεδαΔημιουργήστε ένα παραμετροποιήσιμο επίπεδο υποκατηγοριοποιώντας την `tf.keras.layers.Layer` και υλοποιώντας τις παρακάτω μεθόδους :* `__init__` : (Προαιρετικά) ορίστε τα υποεπίπεδα που θα χρησιμοποιηθούν από το επίπεδο* `build` : Δημιουργεί τα βάρη του επιπέδου. Προσθέστε βάρη με την μέθοδο `add_weight`.* `call` : Ορίστε το "προς τα εμπρός πέρασμα"* Προαιρετικά, ένα επίπεδο μπορεί να σειριοποιηθεί με την υλοποίηση της μεθόδου `get_config` και της μεθόδου κλάσης `from_config`.Ακολουθεί παράδειγμα ενός παραμετροποιήσιμου επιπέδου το οποίο υλοποιεί ένα `matmul` με ορίσματα μία είσοδο και έναν kernel (πυρήνα)
class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape): # Create a trainable weight variable for this layer. self.kernel = self.add_weight(name='kernel', shape=(input_shape[1], self.output_dim), initializer='uniform', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.kernel) def get_config(self): base_config = super(MyLayer, self).get_config() base_config['output_dim'] = self.output_dim return base_config @classmethod def from_config(cls, config): return cls(**config)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Δημιουργήστε ένα μοντέλο χρησιμοποιώντας το δικό σας επίπεδο :
model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')]) # The compile step specifies the training configuration model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) # Trains for 5 epochs. model.fit(data, labels, batch_size=32, epochs=5)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
ΕπανακλήσειςΜία επανάκληση(callback) είναι ένα αντικείμενο το οποίο περνάει σε ένα μοντέλο για να τροποποιήσει και να επεκτείνει τη συμπεριφορά του κατά την διάρκεια της μάθησης. Μπορείτε να γράψετε τις δικές σας επανακλήσεις ή να χρησιμοποιήσετε την `tf.keras.callbacks` η οποία περιλαμβάνει :* `tf.keras.callbacks.ModelCheckpoint`: Αποθηκεύστε το μοντέλο σας ανά τακτά διαστήματα.* `tf.keras.callbacks.LearningRateScheduler`: Δυναμικά, αλλάξτε τον ρυθμό μάθησης.* `tf.keras.callbacks.EarlyStopping`: Διακόψτε την εκμάθηση όταν η απόδοση επαλήθευσης (validation performance) έχει σταματήσει να βελτιώνεται.* `tf.keras.callbacks.TensorBoard`: Παρακολουθήστε την συμπεριφορά του μοντέλου με τη χρήση του [TensorBoard](https://tensorflow.org/tensorboard).Για να χρησιμοποιήσετε την `tf.keras.callbacks.Callback` , περάστε την στην μέθοδο `fit` του μοντέλου :
callbacks = [ # Interrupt training if `val_loss` stops improving for over 2 epochs tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), # Write TensorBoard logs to `./logs` directory tf.keras.callbacks.TensorBoard(log_dir='./logs') ] model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks, validation_data=(val_data, val_labels))
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Αποθήκευση και επαναφορά Αποθήκευση μόνο των τιμών των βαρώνΑποθηκεύστε και φορτώστε τα βάρη ενός μοντέλου με τη χρήση της `tf.keras.Model.save_weights`:
model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy']) # Save weights to a TensorFlow Checkpoint file model.save_weights('./weights/my_model') # Restore the model's state, # this requires a model with the same architecture. model.load_weights('./weights/my_model')
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Ως προεπιλογή , το παραπάνω αποθηκεύει τα βάρη του μοντέλου σε μορφοποίηση [TensorFlow checkpoint](../checkpoint.ipynb). Εναλλακτικά , μπορούν να αποθηκευτούν χρησιμοποιώντας την μορφοποιήση Keras HDF5(η προεπιλογή για την υλοποίηση του συστήματος υποστήριξης του Keras):
# Save weights to a HDF5 file model.save_weights('my_model.h5', save_format='h5') # Restore the model's state model.load_weights('my_model.h5')
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Αποθήκευση μόνο των ρυθμίσεων του μοντέλουΟι ρυθμίσεις ενός μοντέλου μπορούν να αποθηκευτούν-αυτό σειριοποιεί την αρχιτεκτονική του μοντέλου χωρίς βάρη. Οι αποθηκευμένες ρυθμίσεις μπορόυν να αναπαράγουν και να αρχικοποιήσουν το ίδιο μοντέλο, ακόμη και χωρίς τον κώδικα που όρισε το πρότυπο μοντέλο. To Keras υποστηρίζει τα JSON και YAML ως μορφές σειριοποίησης:
# Serialize a model to JSON format json_string = model.to_json() json_string import json import pprint pprint.pprint(json.loads(json_string))
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Αναπαραγωγή του μοντέλου(νεότερα αρχικοποιήθεντος) από το JSON :
fresh_model = tf.keras.models.model_from_json(json_string)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Η σειριοποίηση μοντέλου σε μορφή YAML απαιτεί την εγκατάσταση της `pyyaml` πριν γίνει είσοδος της TensorFlow:
yaml_string = model.to_yaml() print(yaml_string)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Αναπαραγωγή του μοντέλου από το YAML :
fresh_model = tf.keras.models.model_from_yaml(yaml_string)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Προσοχή : Μοντέλα ως υποκλάσεις δεν σειριοποιούνται διότι η αρχιτεκτονική τους ορίζεται από τον κώδικα Python στο σώμα τις μεθόδου `call`. Αποθήκευση ολόκληρου του μοντέλου σε ένα αρχείοΟλόκληρο το μοντέλο μπορεί να αποθηκευτεί σε ένα μόνο αρχείο το οποίο περιέχει τα βάρη , τις ρυθμίσεις του μοντέλου , ακόμη και τις ρυθμίσεις του βελτιστοποιητή. Έτσι , μπορείτε να θέσετε ένα σημείο ελέγχου σε ένα μοντέλο και να συνεχίσετε την εκμάθηση αργότερα - από την ακριβώς ίδια κατάσταση - χωρίς πρόσβαση στον πρωταρχικό κώδικα :
# Create a simple model model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) # Save entire model to a HDF5 file model.save('my_model.h5') # Recreate the exact same model, including weights and optimizer. model = tf.keras.models.load_model('my_model.h5')
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Για να μάθετε περισσότερα για την αποθήκευση και την σειριοποίηση , πατήστε [εδώ](./save_and_serialize.ipynb). "Ενθουσιώδης" εκτέλεση(Eager execution)H ["Ενθουσιώδης" εκτέλεση](https://github.com/tensorflow/docs/blob/master/site/en/guide/eager.ipynb) είναι ένα (επιτακτικό) περιβάλλον προγραμματισμού το οποίο αξιολογεί λειτουργίες αμέσως. Αυτό δεν απαιτείται από το Keras , ωστόσο η `tf.keras` παρέχει υποστήριξη και χρησιμεύει για την επιθεώρηση και την εκσφαλμάτωση του προγράμματος.Όλα τα API της `tf.keras` για την κατασκευή μοντέλων είναι συμβατά με την "ενθουσιώδη εκτέλεση". Και καθώς τα `Σειριακά` και τα λειτουργικά (functional) API μπορούν να χρησιμοποιηθούν, η "ενθουσιώδης" εκτέλεση επωφελεί ιδιαίτερα την υποκατηγοριοποίηση μοντέλων και την κατασκευή παραμετροποιήσιμων επιπέδων-τα ΑPI's που σας προτρέπουν να γράψετε το "προς τα εμπρος πέρασμα" ως κώδικα (σε αντίθεση με τα API's που δημιουργούν μοντέλα μέσω της σύνθεσης των ήδη υπάρχοντων επιπέδων) Δείτε τον οδηγό [αυτό](https://github.com/tensorflow/docs/blob/master/site/en/guide/eager.ipynb) για παραδείγματα χρήσης μοντέλων Keras με custom training looops και την `tf.GradientTape`. Ακόμη , μπορείτε να δείτε ένα ολοκληρωμένο και σύντομο παράδειγμα [εδώ](https://www.tensorflow.org/tutorials/quickstart/advanced). Διανομή Τα μοντέλα της `tf.keras` μπορούν να εκτελεστούν σε πολλαπλές GPUs ,με την χρήση της `tf.distribute.Strategy`. Το API αυτό κατανείμει την μάθηση σε πολλαπλές κάρτες γραφικών με σχεδόν καθόλου αλλαγές στον υπάρχον κώδικα.Επί του παρόντος, η `tf.distribute.MirroredStrategy` αποτελεί την μόνη στρατηγική κατανομής που υποστηρίζεται. Η `MirroredStrategy` πραγματοποιεί in-graph replication μαζί με συγχρονισμένη μάθηση, χρησιμοποιώντας all-reduce σε ένα μηχάνημα. Για να χρησιμοποιήσετε τη `distribute.Strategy`, εμφωλεύστε την αρχικοποίηση του βελτιστοποιητή, τον κατασκευαστή του μοντέλου, και το `compile` σε ένα μπλοκ κώδικα `Strategy.scope()`. Έπειτα , προχωρήστε στην εκμάθηση του μοντέλου.Το ακόλουθο παράδειγμα κατανείμει ένα `tf.keras.Model` σε πολλαπλές κάρτες γραφικών σε ένα μηχάνημα.Πρώτα , ορίζεται ένα μοντέλο εντός της `distribute.Strategy`:
strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Στη συνέχεια , εξασκείστε το μοντέλο πάνω σε δεδομένα κατά τα γνωστά :
x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)
_____no_output_____
Apache-2.0
site/el/guide/keras/overview.ipynb
KarimaTouati/docs-l10n
Imports
!pip install gensim !pip nltk # Import the libraries import gensim from glob import glob import pandas as pd from tqdm import tqdm, tqdm_notebook from gensim.test.utils import common_texts from gensim.models.doc2vec import Doc2Vec, TaggedDocument import nltk from nltk.tokenize import word_tokenize from nltk.corpus import stopwords import string np = pd.np # Load data for text processing #For removing punctuation table = str.maketrans('', '', string.punctuation) nltk.download('stopwords') stop_words = set(stopwords.words('english')) #For Displaying progress tqdm_notebook(disable = True).pandas() ''' Reads articles from the given path. path : path format from which files have to be read. e.g. ./*.cvs will read all csvs Params: show_progress : Shows the progress using tqdm if True else nothing displayed ''' def read_articles(path, show_progress = True): df_list = [] for file_name in tqdm_notebook(glob(path), disable = not show_progress): temp_df = pd.read_csv(file_name, index_col=0) temp_df["date"] = file_name.split("/")[-1].split('.')[0] df_list.append(temp_df) df = pd.concat(df_list, ignore_index=True) df["date"] = pd.to_datetime(df["date"]) return df ''' For the given text, returns a list of words representing the text with all words in lower case and punctuation along with stopwords removed Params: text : Text for which vocubulary has to be generated ''' def generate_document_vocabulary(text): vocabulary = [] for word in word_tokenize(text): w = word.translate(table).lower() if w.isalpha() and w not in stop_words: vocabulary.append(w) return vocabulary
_____no_output_____
MIT
TOI/Doc2Vec.ipynb
aashish-jain/Social-unrest-prediction
All the CSVs contain the following datadate, title(headline), location, text(full article) Data pre-processing for doc2vec
# Read articles df = read_articles("../data/TOI/*.csv") # Take training data (until 1-Jan-2019) df = df[df["date"] < pd.to_datetime("1-Jan-2019")] # Get the vocabulary from the given text df['vocabulary'] = df['text'].progress_apply(generate_document_vocabulary) #Convert the vocabulary into Tagged document for doc2vec model documents = [] for i, row in df.iterrows(): document = TaggedDocument(row['vocabulary'], [i]) documents.append(document)
_____no_output_____
MIT
TOI/Doc2Vec.ipynb
aashish-jain/Social-unrest-prediction