Datasets:

---

bigcode

/

jupyter-parsed

like 4

Follow

BigCode 1.35k

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## Stack - Bootcamp de Data Science", "_____no_output_____" ], [ "### Machine Learning.", "_____no_output_____" ] ], [ [ "import pandas as pd\nimport datetime\nimport glob\nfrom minio import Minio\nimport numpy as np\nimport matplotlib.pyplot as plt", "_____no_output_____" ], [ "client = Minio(\n \"localhost:9000\",\n access_key=\"minioadmin\",\n secret_key=\"minioadmin\",\n secure=False\n )", "_____no_output_____" ] ], [ [ "### Baixando o Dataset do Data Lake.", "_____no_output_____" ] ], [ [ "client.fget_object(\n \"processing\",\n \"employees_dataset.parquet\",\n \"temp_.parquet\",\n)\ndf = pd.read_parquet(\"temp_.parquet\")", "_____no_output_____" ], [ "df.head()", "_____no_output_____" ] ], [ [ "#### Organizando o dataset.", "_____no_output_____" ] ], [ [ "df = df[['department', 'salary', 'mean_work_last_3_months',\n 'number_projects', 'satisfaction_level', 'last_evaluation',\n 'time_in_company', 'work_accident','left']]", "_____no_output_____" ], [ "df.head()", "_____no_output_____" ] ], [ [ "#### Verificando os registros missing.", "_____no_output_____" ] ], [ [ "df.isnull().sum()", "_____no_output_____" ], [ "df[df.notnull()]", "_____no_output_____" ], [ "df = df[:14998]", "_____no_output_____" ] ], [ [ "#### Alterando os tipos de dados.", "_____no_output_____" ] ], [ [ "df[\"number_projects\"] = df[\"number_projects\"].astype(int)\ndf[\"mean_work_last_3_months\"] = df[\"mean_work_last_3_months\"].astype(int)\ndf[\"time_in_company\"] = df[\"time_in_company\"].astype(int)\ndf[\"work_accident\"] = df[\"work_accident\"].astype(int)\ndf[\"left\"] = df[\"left\"].astype(int)", "_____no_output_____" ], [ "df.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 14998 entries, 0 to 14997\nData columns (total 9 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 department 14998 non-null object \n 1 salary 14998 non-null object \n 2 mean_work_last_3_months 14998 non-null int64 \n 3 number_projects 14998 non-null int64 \n 4 satisfaction_level 14998 non-null float64\n 5 last_evaluation 14998 non-null float64\n 6 time_in_company 14998 non-null int64 \n 7 work_accident 14998 non-null int64 \n 8 left 14998 non-null int64 \ndtypes: float64(2), int64(5), object(2)\nmemory usage: 1.0+ MB\n" ], [ "df.head()", "_____no_output_____" ], [ "df = df[:14998]", "_____no_output_____" ] ], [ [ "#### Renomeando atributos", "_____no_output_____" ] ], [ [ "df = df.rename(columns={'satisfaction_level': 'satisfaction', \n 'last_evaluation': 'evaluation',\n 'number_projects': 'projectCount',\n 'mean_work_last_3_months': 'averageMonthlyHours',\n 'time_in_company': 'yearsAtCompany',\n 'work_accident': 'workAccident',\n 'left' : 'turnover'\n })", "_____no_output_____" ], [ "df.head()", "_____no_output_____" ] ], [ [ "### Importancia de Features", "_____no_output_____" ], [ "#### Converte os atributos em categoricos.", "_____no_output_____" ] ], [ [ "df[\"department\"] = df[\"department\"].astype('category').cat.codes\ndf[\"salary\"] = df[\"salary\"].astype('category').cat.codes", "_____no_output_____" ], [ "df.head()", "_____no_output_____" ] ], [ [ "#### Separando os conjuntos de dados em features e em classe\nNosso problema é um de `classificação`", "_____no_output_____" ] ], [ [ "# nosso atributo classe é o turnover\ntarget_name = 'turnover'\n# o x vai representa nossa features sem o turnover\nX = df.drop('turnover', axis=1)\ny = df[target_name]", "_____no_output_____" ] ], [ [ "#### Transformando os dados.", "_____no_output_____" ] ], [ [ "from sklearn.preprocessing import MinMaxScaler", "_____no_output_____" ] ], [ [ "#### MinMaxScaler\nPara cada valor em um recurso, `MinMaxScaler` subtrai o valor mínimo no recurso e, em seguida, divide pelo intervalo. \n - O intervalo é a diferença entre o máximo original e o mínimo original.\n - MinMaxScaler preserva a forma da distribuição original. Isso não altera significativamente as informações incorporadas nos dados originais.\n - Observe que MinMaxScaler não reduz a importância de outliers.\n - O intervalo padrão para o recurso retornado por MinMaxScaler é de 0 a 1.\n\n", "_____no_output_____" ] ], [ [ "scaler = MinMaxScaler()", "_____no_output_____" ], [ "# Fazendo a transformação\nX = scaler.fit_transform(X)", "_____no_output_____" ], [ "X", "_____no_output_____" ] ], [ [ "#### Separando os conjuntos de treino e testes", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import train_test_split", "_____no_output_____" ], [ "X_train, X_test, y_train, y_test = train_test_split(\n X # conjunto das features\n ,y # é a classe\n ,test_size = 0.2 # 20% do conjunto, vai ser usado para testes\n ,random_state = 123 # semente aleatoria\n ,stratify = y # separação dos dados mantendo um numeros de classes(fazendo um balanceamento de classes) \n)", "_____no_output_____" ] ], [ [ "#### Treinando o algoritmo de arvore de decisão.", "_____no_output_____" ] ], [ [ "from sklearn.tree import DecisionTreeClassifier", "_____no_output_____" ], [ "dtree = DecisionTreeClassifier()\ndtree = dtree.fit(X_train,y_train)", "_____no_output_____" ], [ "importances = dtree.feature_importances_\nfeat_names = df.drop(['turnover'],axis=1).columns", "_____no_output_____" ], [ "indices = np.argsort(importances)[::-1]\nplt.figure(figsize=(12,4))\nplt.title(\"Feature importances by DecisionTreeClassifier\")\nplt.bar(range(len(indices)), importances[indices], color='lightblue', align=\"center\")\nplt.xticks(range(len(indices)), feat_names[indices], rotation='vertical',fontsize=14)\nplt.xlim([-1, len(indices)])\nplt.show()", "_____no_output_____" ] ], [ [ "#### Filtrando apenas os atributos relevantes.", "_____no_output_____" ] ], [ [ "X = df[[\"satisfaction\",\"evaluation\",\"averageMonthlyHours\",\"yearsAtCompany\"]]", "_____no_output_____" ] ], [ [ "#### Separando os conjuntos de dados.", "_____no_output_____" ] ], [ [ "scaler = MinMaxScaler()", "_____no_output_____" ], [ "X = scaler.fit_transform(X)", "_____no_output_____" ], [ "X_train, X_test, y_train, y_test = train_test_split(\n X\n ,y\n ,test_size = 0.2\n ,random_state = 123\n ,stratify = y\n)", "_____no_output_____" ], [ "X_train", "_____no_output_____" ] ], [ [ "#### Função do modelo de base.", "_____no_output_____" ] ], [ [ "def base_rate_model(X) :\n y = np.zeros(X.shape[0])\n return y", "_____no_output_____" ] ], [ [ "#### Importando métodos de métrica de avaliação.", "_____no_output_____" ] ], [ [ "from sklearn.metrics import roc_auc_score\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.metrics import classification_report", "_____no_output_____" ], [ "def accuracy_result(y_test,y_predict):\n acc = accuracy_score(y_test, y_predict)\n print (\"Accuracy = %2.2f\" % acc)", "_____no_output_____" ], [ "def roc_classification_report_results(model,y_test,y_predict):\n roc_ = roc_auc_score(y_test, y_predict)\n classfication_report = classification_report(y_test, y_predict)\n \n print (\"\\n{} AUC = {}\\n\".format(model, roc_))\n print(classfication_report)", "_____no_output_____" ] ], [ [ "#### Análise do modelo de baseline", "_____no_output_____" ] ], [ [ "y_predict = base_rate_model(X_test)", "_____no_output_____" ], [ "accuracy_result(y_test, y_predict)", "Accuracy = 0.76\n" ], [ "roc_classification_report_results(\"Base Model\", y_test, y_predict)", "\nBase Model AUC = 0.5\n\n precision recall f1-score support\n\n 0 0.76 1.00 0.86 2286\n 1 0.00 0.00 0.00 714\n\n accuracy 0.76 3000\n macro avg 0.38 0.50 0.43 3000\nweighted avg 0.58 0.76 0.66 3000\n\n" ] ], [ [ "### Modelo de Regressão Logística.", "_____no_output_____" ], [ "#### Instânciando o algoritmo.", "_____no_output_____" ] ], [ [ "from sklearn.linear_model import LogisticRegression\nlogis = LogisticRegression()", "_____no_output_____" ] ], [ [ "#### Realizando o treinamento.", "_____no_output_____" ] ], [ [ "logis.fit(X_train, y_train)", "_____no_output_____" ] ], [ [ "#### Calculando as predições.", "_____no_output_____" ] ], [ [ "y_predict = logis.predict(X_test)", "_____no_output_____" ] ], [ [ "#### Avaliando o resultado.", "_____no_output_____" ] ], [ [ "accuracy_result(y_test, y_predict)", "Accuracy = 0.76\n" ], [ "roc_classification_report_results(\"Logistic Regression\", y_test, y_predict)", "\nLogistic Regression AUC = 0.5897884088018409\n\n precision recall f1-score support\n\n 0 0.80 0.92 0.85 2286\n 1 0.50 0.26 0.34 714\n\n accuracy 0.76 3000\n macro avg 0.65 0.59 0.60 3000\nweighted avg 0.73 0.76 0.73 3000\n\n" ] ], [ [ "### Modelo de Arvore de decisão.", "_____no_output_____" ], [ "#### Instânciando o algoritmo.", "_____no_output_____" ] ], [ [ "from sklearn.tree import DecisionTreeClassifier\ndtree = DecisionTreeClassifier()", "_____no_output_____" ] ], [ [ "#### Realizando o treinamento.", "_____no_output_____" ] ], [ [ "dtree = dtree.fit(X_train,y_train)", "_____no_output_____" ] ], [ [ "#### Calculando as predições.", "_____no_output_____" ] ], [ [ "y_predict = dtree.predict(X_test)", "_____no_output_____" ] ], [ [ "#### Avaliando o resultado.", "_____no_output_____" ] ], [ [ "accuracy_result(y_test, y_predict)", "Accuracy = 0.96\n" ], [ "roc_classification_report_results(\"Decision Tree\", y_test, y_predict)", "\nDecision Tree AUC = 0.9462622319268915\n\n precision recall f1-score support\n\n 0 0.98 0.97 0.97 2286\n 1 0.90 0.93 0.91 714\n\n accuracy 0.96 3000\n macro avg 0.94 0.95 0.94 3000\nweighted avg 0.96 0.96 0.96 3000\n\n" ] ], [ [ "### Modelo de Arvore Aleatória (Random Forest)", "_____no_output_____" ], [ "#### Instânciando o algoritmo.", "_____no_output_____" ] ], [ [ "from sklearn.ensemble import RandomForestClassifier", "_____no_output_____" ], [ "rf = RandomForestClassifier()", "_____no_output_____" ] ], [ [ "#### Realizando o treinamento.", "_____no_output_____" ] ], [ [ "rf = rf.fit(X_train,y_train)", "_____no_output_____" ] ], [ [ "#### Calculando as predições.", "_____no_output_____" ] ], [ [ "y_predict = rf.predict(X_test)", "_____no_output_____" ] ], [ [ "#### Avaliando o resultado.", "_____no_output_____" ] ], [ [ "accuracy_result(y_test, y_predict)", "Accuracy = 0.97\n" ], [ "roc_classification_report_results(\"Random Forest\", y_test, y_predict)", "\nRandom Forest AUC = 0.9535664659564612\n\n precision recall f1-score support\n\n 0 0.98 0.99 0.98 2286\n 1 0.95 0.92 0.94 714\n\n accuracy 0.97 3000\n macro avg 0.96 0.95 0.96 3000\nweighted avg 0.97 0.97 0.97 3000\n\n" ] ], [ [ "### Pycaret", "_____no_output_____" ] ], [ [ "#pip install pycaret", "_____no_output_____" ] ], [ [ "#### Importando os métodos.", "_____no_output_____" ] ], [ [ "from pycaret.classification import *", "_____no_output_____" ] ], [ [ "#### Definindo o Setup.", "_____no_output_____" ] ], [ [ "s = setup( df[[\"satisfaction\",\"evaluation\",\"averageMonthlyHours\",\"yearsAtCompany\",\"turnover\"]]\n ,target = \"turnover\"\n ,numeric_features = [\"yearsAtCompany\"]\n ,normalize = True\n ,normalize_method = \"minmax\"\n ,data_split_stratify = True\n ,fix_imbalance = True,\n )", "_____no_output_____" ] ], [ [ "#### Comparando diferentes modelos.", "_____no_output_____" ] ], [ [ "best = compare_models(fold = 5,sort = 'AUC',)", "_____no_output_____" ] ], [ [ "#### Criando o modelo.", "_____no_output_____" ] ], [ [ "gbc = create_model('gbc', fold = 5)", "_____no_output_____" ] ], [ [ "#### Realizando o tunning do modelo.", "_____no_output_____" ] ], [ [ "tuned_gbc = tune_model(gbc\n ,fold = 5\n ,custom_grid = {\"learning_rate\":[0.1,0.2,0.5]\n ,\"n_estimators\":[100,500,1000]\n ,\"min_samples_split\":[1,2,5,10]\n ,\"max_depth\":[1,3,9]\n }\n ,optimize = 'AUC')", "_____no_output_____" ] ], [ [ "#### Finalizando o modelo.", "_____no_output_____" ] ], [ [ "final_model = finalize_model(tuned_gbc)", "_____no_output_____" ], [ "save_model(final_model,'model')", "Transformation Pipeline and Model Successfully Saved\n" ] ], [ [ "#### Transferindo os arquivos para o Data Lake.", "_____no_output_____" ], [ "#### Modelo de Classificação.", "_____no_output_____" ] ], [ [ "client.fput_object(\n \"curated\",\n \"model.pkl\",\n \"model.pkl\"\n)", "_____no_output_____" ] ], [ [ "#### Exportando o conjunto de dados para o disco.", "_____no_output_____" ] ], [ [ "df.to_csv(\"dataset.csv\",index=False)", "_____no_output_____" ], [ "client.fput_object(\n \"curated\",\n \"dataset.csv\",\n \"dataset.csv\"\n)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy as np\nimport matplotlib.pyplot as plt\nfrom IPython.core.display import HTML\nimport pydae.svg_tools as svgt\n%config InlineBackend.figure_format = 'svg'", "_____no_output_____" ], [ "%matplotlib widget", "_____no_output_____" ], [ "from pydae import ssa\nfrom lead_lag import lead_lag_class", "_____no_output_____" ], [ "syst = lead_lag_class()", "_____no_output_____" ], [ "\nsyst.initialize([{ # parameters setting\n # initial desired angle = 0º\n }],-1) # here -1 means that -1 is considered as initial gess for\n # dynamic and algebraic states", "_____no_output_____" ], [ "syst.report_y()", "z_l = 0.00\n" ], [ "syst.simulate([{'t_end':1.0, 'u_l':0.0, 'T_1':0.1, 'T_2':0.1},\n {'t_end':5.0, 'u_l':0.5}],0);", "_____no_output_____" ], [ "fig, axes = plt.subplots(nrows=1,ncols=1, figsize=(6, 3), dpi=100)\n\naxes.plot(syst.T, syst.get_values('z_l'), label=f'z_l')\naxes.set_ylabel('$\\\\theta (º)$')\naxes.set_xlabel('Time (s)')\nfig.tight_layout()", "_____no_output_____" ], [ "Δt = 0.001\nsyst = lead_lag_class()\ntimes = np.arange(0,5,Δt)\nsyst.initialize([{'u_l':0.0, 'T_1':1.0, 'T_2':0.1}],0)\n\nfor t in times:\n syst.run([{'t_end':t,'u_l':np.sin(1*np.pi*2*t)}])\n \nsyst.post();\n", "_____no_output_____" ], [ "fig, axes = plt.subplots(nrows=1,ncols=1, figsize=(6, 3), dpi=100)\n\naxes.plot(syst.T, syst.get_values('u_l'), label=f'u_l')\naxes.plot(syst.T, syst.get_values('z_l'), label=f'z_l')\naxes.legend()\naxes.set_xlabel('Time (s)')\nfig.tight_layout()", "_____no_output_____" ], [ "import ipywidgets\n%matplotlib widget", "_____no_output_____" ], [ "plt.ioff()\nplt.clf()\nsyst = lead_lag_class()\nsyst.initialize([{'u_l':0.0, 'T_1':1.0, 'T_2':0.1}],0)\nfig, axes = plt.subplots(nrows=1,ncols=1, figsize=(6, 3), dpi=100)\n\nline_u_l = axes.plot(syst.T, syst.get_values('u_l'), label=f'u_l')\nline_z_l = axes.plot(syst.T, syst.get_values('z_l'), label=f'z_l')\naxes.legend()\naxes.set_xlabel('Time (s)')\nfig.tight_layout()\n\n\n\naxes.set_ylim((-2,2))\naxes.set_xlim((0,50))\n\naxes.grid(True)\naxes.legend(loc='best')\nfig.tight_layout()\n\n\nsld_T_1 = ipywidgets.FloatSlider(orientation='horizontal',description = \"$\\sf T_1$\", \n value=0.1, min=-0.5,max= 2.0, \n step=0.01,continuous_update=False)\n\n\nsld_T_2 = ipywidgets.FloatSlider(orientation='horizontal',description = \"$\\sf T_2$\", \n value=0.1, min=0.05,max= 10.0, \n step=0.01,continuous_update=False)\n\nsld_freq = ipywidgets.FloatSlider(orientation='horizontal',description = \"$\\sf freq$\", \n value=1.0, min=0.1,max= 2.0, \n step=0.1)\n\nckbox_gain = ipywidgets.Checkbox(\n value=False,\n description='Gain compensation',\n disabled=False\n)\n\ntxt_phase = ipywidgets.Text(\n value='1∠0º',\n placeholder='Type something',\n description='gain∠phase:',\n disabled=False)\n\ndrop_signal = ipywidgets.Dropdown(\n options=['sin(wt)', 'step'],\n value='sin(wt)',\n description='Input:',\n disabled=False,\n)\n\n\n\nΔt = 0.01\ntimes = np.arange(0,5,Δt)\n\ndef update(change):\n \n T_1 = sld_T_1.value\n T_2 = sld_T_2.value\n freq = sld_freq.value\n \n cplx_ = (1j*2*np.pi*freq*T_1 + 1)/(1j*2*np.pi*freq*T_2 + 1)\n phase_wo = np.angle(cplx_,deg=True)\n \n gain_wo = 1.0\n if ckbox_gain.value:\n gain_wo = np.abs(cplx_)\n \n \n txt_phase.value = f'{np.abs(cplx_):4.1f}∠{phase_wo:4.1f}º'\n \n syst.initialize([{'u_l':0.0, 'T_1':T_1, 'T_2':T_2}],0)\n \n if drop_signal.value == 'sin(wt)':\n for t in times:\n syst.run([{'t_end':t,'u_l':np.sin(2*np.pi*freq*t)}])\n if drop_signal.value == 'step':\n syst.run([{'t_end':50,'u_l':1.0, 'Dt':0.01}])\n \n\n syst.post();\n\n line_u_l[0].set_data(syst.T, syst.get_values('u_l'))\n line_z_l[0].set_data(syst.T, syst.get_values('z_l')/gain_wo)\n\n fig.canvas.draw_idle()\n \nsld_T_1.observe(update, names='value')\nsld_T_2.observe(update, names='value')\nsld_freq.observe(update, names='value')\nckbox_gain.observe(update, names='value')\ndrop_signal.observe(update, names='value')\n\nlayout_row1 = ipywidgets.HBox([fig.canvas])\nlayout_row2 = ipywidgets.HBox([sld_T_1,sld_T_2, txt_phase])\nlayout_row3 = ipywidgets.HBox([sld_freq,ckbox_gain,drop_signal])\nlayout = ipywidgets.VBox([layout_row1,layout_row2,layout_row3])\nlayout", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy as np\nimport matplotlib.pyplot as plt\n\nplt.rc('axes', grid=False) # turn off the background grid for images", "_____no_output_____" ], [ "Topo = plt.imread('Earth_50.png')\nprint Topo.shape, Topo.dtype", "_____no_output_____" ] ], [ [ "### Impact Craters", "_____no_output_____" ] ], [ [ "TestLat = np.array([0,45,60,-45,-60])\nTestLon = np.array([0,-45,-90,45,90])\n\nLatD,LatM,LonD,LonM = np.loadtxt('World.csv', delimiter=',', usecols=(2,3,4,5), unpack=True)\n\nImY,ImX = Topo.shape[0:-1]\n\nMapY = -ImY/180.0 * LatD + ImY/2.0\nMapX = (ImX/360.0 * LonD) + ImX/2.0\n\n#mask1 = np.where(MapX > ImX)\n#MapX[mask1] -= ImX", "_____no_output_____" ], [ "#fig = plt.figure()\n#ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])\n\nfig, ax = plt.subplots(1,1)\nfig.set_size_inches(10,5)\nfig.tight_layout()\n\nax.autoscale_view('tight')\nax.set_axis_off()\n\nax.scatter(MapX,MapY,marker='o',s=30,color='y', edgecolor='k')\nax.imshow(Topo)\n", "_____no_output_____" ], [ "fig.savefig('EarthCraters_RAW.png', dpi=300, bbox_inches='tight',pad_inches=0)", "_____no_output_____" ] ] ]

[ "code", "markdown", "code" ]

[ [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "##### Copyright 2019 The TensorFlow Authors.", "_____no_output_____" ] ], [ [ "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.", "_____no_output_____" ] ], [ [ "# How to train Boosted Trees models in TensorFlow", "_____no_output_____" ], [ "<table class=\"tfo-notebook-buttons\" align=\"left\">\n <td>\n <a target=\"_blank\" href=\"https://www.tensorflow.org/beta/tutorials/estimators/boosted_trees\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/r2/tutorials/estimators/boosted_trees.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/en/r2/tutorials/estimators/boosted_trees.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\">View source on GitHub</a>\n </td>\n</table>", "_____no_output_____" ], [ "This tutorial is an end-to-end walkthrough of training a Gradient Boosting model using decision trees with the `tf.estimator` API. Boosted Trees models are among the most popular and effective machine learning approaches for both regression and classification. It is an ensemble technique that combines the predictions from several (think 10s, 100s or even 1000s) tree models.\n\nBoosted Trees models are popular with many machine learning practitioners as they can achieve impressive performance with minimal hyperparameter tuning.", "_____no_output_____" ], [ "## Load the titanic dataset\nYou will be using the titanic dataset, where the (rather morbid) goal is to predict passenger survival, given characteristics such as gender, age, class, etc.", "_____no_output_____" ] ], [ [ "from __future__ import absolute_import, division, print_function, unicode_literals\n\nimport numpy as np\nimport pandas as pd\nfrom IPython.display import clear_output\nfrom matplotlib import pyplot as plt\n\n# Load dataset.\ndftrain = pd.read_csv('https://storage.googleapis.com/tf-datasets/titanic/train.csv')\ndfeval = pd.read_csv('https://storage.googleapis.com/tf-datasets/titanic/eval.csv')\ny_train = dftrain.pop('survived')\ny_eval = dfeval.pop('survived')", "_____no_output_____" ], [ "try:\n !pip install tf-nightly-2.0-preview\nexcept Exception:\n pass\nimport tensorflow as tf\ntf.random.set_seed(123)", "_____no_output_____" ] ], [ [ "The dataset consists of a training set and an evaluation set:\n\n* `dftrain` and `y_train` are the *training set*—the data the model uses to learn.\n* The model is tested against the *eval set*, `dfeval`, and `y_eval`.\n\nFor training you will use the following features:\n\n\n<table>\n <tr>\n <th>Feature Name</th>\n <th>Description</th>\n </tr>\n <tr>\n <td>sex</td>\n <td>Gender of passenger</td>\n </tr>\n <tr>\n <td>age</td>\n <td>Age of passenger</td>\n </tr>\n <tr>\n <td>n_siblings_spouses</td>\n <td># siblings and partners aboard</td>\n </tr>\n <tr>\n <td>parch</td>\n <td># of parents and children aboard</td>\n </tr>\n <tr>\n <td>fare</td>\n <td>Fare passenger paid.</td>\n </tr>\n <tr>\n <td>class</td>\n <td>Passenger's class on ship</td>\n </tr>\n <tr>\n <td>deck</td>\n <td>Which deck passenger was on</td>\n </tr>\n <tr>\n <td>embark_town</td>\n <td>Which town passenger embarked from</td>\n </tr>\n <tr>\n <td>alone</td>\n <td>If passenger was alone</td>\n </tr>\n</table>", "_____no_output_____" ], [ "## Explore the data", "_____no_output_____" ], [ "Let's first preview some of the data and create summary statistics on the training set.", "_____no_output_____" ] ], [ [ "dftrain.head()", "_____no_output_____" ], [ "dftrain.describe()", "_____no_output_____" ] ], [ [ "There are 627 and 264 examples in the training and evaluation sets, respectively.", "_____no_output_____" ] ], [ [ "dftrain.shape[0], dfeval.shape[0]", "_____no_output_____" ] ], [ [ "The majority of passengers are in their 20's and 30's.", "_____no_output_____" ] ], [ [ "dftrain.age.hist(bins=20)\nplt.show()", "_____no_output_____" ] ], [ [ "There are approximately twice as male passengers as female passengers aboard.", "_____no_output_____" ] ], [ [ "dftrain.sex.value_counts().plot(kind='barh')\nplt.show()", "_____no_output_____" ] ], [ [ "The majority of passengers were in the \"third\" class.", "_____no_output_____" ] ], [ [ "dftrain['class'].value_counts().plot(kind='barh')\nplt.show()", "_____no_output_____" ] ], [ [ "Most passengers embarked from Southampton.", "_____no_output_____" ] ], [ [ "dftrain['embark_town'].value_counts().plot(kind='barh')\nplt.show()", "_____no_output_____" ] ], [ [ "Females have a much higher chance of surviving vs. males. This will clearly be a predictive feature for the model.", "_____no_output_____" ] ], [ [ "pd.concat([dftrain, y_train], axis=1).groupby('sex').survived.mean().plot(kind='barh').set_xlabel('% survive')\nplt.show()", "_____no_output_____" ] ], [ [ "## Create feature columns and input functions\nThe Gradient Boosting estimator can utilize both numeric and categorical features. Feature columns work with all TensorFlow estimators and their purpose is to define the features used for modeling. Additionally they provide some feature engineering capabilities like one-hot-encoding, normalization, and bucketization. In this tutorial, the fields in `CATEGORICAL_COLUMNS` are transformed from categorical columns to one-hot-encoded columns ([indicator column](https://www.tensorflow.org/api_docs/python/tf/feature_column/indicator_column)):", "_____no_output_____" ] ], [ [ "fc = tf.feature_column\nCATEGORICAL_COLUMNS = ['sex', 'n_siblings_spouses', 'parch', 'class', 'deck',\n 'embark_town', 'alone']\nNUMERIC_COLUMNS = ['age', 'fare']\n\ndef one_hot_cat_column(feature_name, vocab):\n return tf.feature_column.indicator_column(\n tf.feature_column.categorical_column_with_vocabulary_list(feature_name,\n vocab))\nfeature_columns = []\nfor feature_name in CATEGORICAL_COLUMNS:\n # Need to one-hot encode categorical features.\n vocabulary = dftrain[feature_name].unique()\n feature_columns.append(one_hot_cat_column(feature_name, vocabulary))\n\nfor feature_name in NUMERIC_COLUMNS:\n feature_columns.append(tf.feature_column.numeric_column(feature_name,\n dtype=tf.float32))", "_____no_output_____" ] ], [ [ "You can view the transformation that a feature column produces. For example, here is the output when using the `indicator_column` on a single example:", "_____no_output_____" ] ], [ [ "example = dict(dftrain.head(1))\nclass_fc = tf.feature_column.indicator_column(tf.feature_column.categorical_column_with_vocabulary_list('class', ('First', 'Second', 'Third')))\nprint('Feature value: \"{}\"'.format(example['class'].iloc[0]))\nprint('One-hot encoded: ', tf.keras.layers.DenseFeatures([class_fc])(example).numpy())", "Feature value: \"Third\"\nOne-hot encoded: [[ 0. 0. 1.]]\n" ] ], [ [ "Additionally, you can view all of the feature column transformations together:", "_____no_output_____" ] ], [ [ "tf.keras.layers.DenseFeatures(feature_columns)(example).numpy()", "_____no_output_____" ] ], [ [ "Next you need to create the input functions. These will specify how data will be read into our model for both training and inference. You will use the `from_tensor_slices` method in the [`tf.data`](https://www.tensorflow.org/api_docs/python/tf/data) API to read in data directly from Pandas. This is suitable for smaller, in-memory datasets. For larger datasets, the tf.data API supports a variety of file formats (including [csv](https://www.tensorflow.org/api_docs/python/tf/data/experimental/make_csv_dataset)) so that you can process datasets that do not fit in memory.", "_____no_output_____" ] ], [ [ "# Use entire batch since this is such a small dataset.\nNUM_EXAMPLES = len(y_train)\n\ndef make_input_fn(X, y, n_epochs=None, shuffle=True):\n def input_fn():\n dataset = tf.data.Dataset.from_tensor_slices((dict(X), y))\n if shuffle:\n dataset = dataset.shuffle(NUM_EXAMPLES)\n # For training, cycle thru dataset as many times as need (n_epochs=None).\n dataset = dataset.repeat(n_epochs)\n # In memory training doesn't use batching.\n dataset = dataset.batch(NUM_EXAMPLES)\n return dataset\n return input_fn\n\n# Training and evaluation input functions.\ntrain_input_fn = make_input_fn(dftrain, y_train)\neval_input_fn = make_input_fn(dfeval, y_eval, shuffle=False, n_epochs=1)", "_____no_output_____" ] ], [ [ "## Train and evaluate the model\n\nBelow you will do the following steps:\n\n1. Initialize the model, specifying the features and hyperparameters.\n2. Feed the training data to the model using the `train_input_fn` and train the model using the `train` function.\n3. You will assess model performance using the evaluation set—in this example, the `dfeval` DataFrame. You will verify that the predictions match the labels from the `y_eval` array.\n\nBefore training a Boosted Trees model, let's first train a linear classifier (logistic regression model). It is best practice to start with simpler model to establish a benchmark.", "_____no_output_____" ] ], [ [ "linear_est = tf.estimator.LinearClassifier(feature_columns)\n\n# Train model.\nlinear_est.train(train_input_fn, max_steps=100)\n\n# Evaluation.\nresult = linear_est.evaluate(eval_input_fn)\nclear_output()\nprint(pd.Series(result))", "accuracy 0.765152\naccuracy_baseline 0.625000\nauc 0.832844\nauc_precision_recall 0.789631\naverage_loss 0.478908\nglobal_step 100.000000\nlabel/mean 0.375000\nloss 0.478908\nprecision 0.703297\nprediction/mean 0.350790\nrecall 0.646465\ndtype: float64\n" ] ], [ [ "Next let's train a Boosted Trees model. For boosted trees, regression (`BoostedTreesRegressor`) and classification (`BoostedTreesClassifier`) are supported. Since the goal is to predict a class - survive or not survive, you will use the `BoostedTreesClassifier`.\n\n\n", "_____no_output_____" ] ], [ [ "# Since data fits into memory, use entire dataset per layer. It will be faster.\n# Above one batch is defined as the entire dataset.\nn_batches = 1\nest = tf.estimator.BoostedTreesClassifier(feature_columns,\n n_batches_per_layer=n_batches)\n\n# The model will stop training once the specified number of trees is built, not\n# based on the number of steps.\nest.train(train_input_fn, max_steps=100)\n\n# Eval.\nresult = est.evaluate(eval_input_fn)\nclear_output()\nprint(pd.Series(result))", "accuracy 0.829545\naccuracy_baseline 0.625000\nauc 0.872788\nauc_precision_recall 0.857807\naverage_loss 0.411839\nglobal_step 100.000000\nlabel/mean 0.375000\nloss 0.411839\nprecision 0.793478\nprediction/mean 0.381942\nrecall 0.737374\ndtype: float64\n" ] ], [ [ "Now you can use the train model to make predictions on a passenger from the evaluation set. TensorFlow models are optimized to make predictions on a batch, or collection, of examples at once. Earlier, the `eval_input_fn` is defined using the entire evaluation set.", "_____no_output_____" ] ], [ [ "pred_dicts = list(est.predict(eval_input_fn))\nprobs = pd.Series([pred['probabilities'][1] for pred in pred_dicts])\n\nprobs.plot(kind='hist', bins=20, title='predicted probabilities')\nplt.show()", "_____no_output_____" ] ], [ [ "Finally you can also look at the receiver operating characteristic (ROC) of the results, which will give us a better idea of the tradeoff between the true positive rate and false positive rate.", "_____no_output_____" ] ], [ [ "from sklearn.metrics import roc_curve\n\nfpr, tpr, _ = roc_curve(y_eval, probs)\nplt.plot(fpr, tpr)\nplt.title('ROC curve')\nplt.xlabel('false positive rate')\nplt.ylabel('true positive rate')\nplt.xlim(0,)\nplt.ylim(0,)\nplt.show()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# \"data/nine_dreams/ninedreams.txt\" IS REQUIRED", "_____no_output_____" ], [ "# SPECIFY FILE ENCODING TYOE IN PYTHON", "_____no_output_____" ] ], [ [ "# -*- coding: utf-8 -*-\nprint (\"UTF-8 ENCODING\")", "UTF-8 ENCODING\n" ] ], [ [ "# LOAD PACKAGES", "_____no_output_____" ] ], [ [ "import chardet # https://github.com/chardet/chardet\nimport glob\nimport codecs\nimport sys\nimport os\nfrom TextLoader import *\nfrom Hangulpy3 import *\nprint (\"PACKAGES LOADED\") ", "PACKAGES LOADED\n" ] ], [ [ "# CONVERT UTF8-ENCODED TXT FILE", "_____no_output_____" ] ], [ [ "def conv_file(fromfile, tofile):\n with open(fromfile, \"rb\") as f:\n sample_text=f.read(10240)\n pred = chardet.detect(sample_text)\n if not pred['encoding'] in ('EUC-KR', 'UTF-8', 'CP949', 'UTF-16LE'):\n print (\"WARNING! Unknown encoding! : %s = %s\") % (fromfile, pred['encoding'])\n pred['encoding'] = \"CP949\" # 못찾으면 기본이 CP949\n formfile = fromfile + \".unknown\"\n elif pred['confidence'] < 0.9:\n print (\"WARNING! Unsured encofing! : %s = %s / %s\")\n % (fromfile, pred['confidence'], pred['encoding'])\n formfile = fromfile + \".notsure\"\n with codecs.open(fromfile, \"r\", encoding=pred['encoding'], errors=\"ignore\") as f:\n with codecs.open(tofile, \"w+\", encoding=\"utf8\") as t:\n all_text = f.read()\n t.write(all_text)", "_____no_output_____" ] ], [ [ "# \"data/nine_dreams/ninedreams_utf8.txt\" IS GENERATED", "_____no_output_____" ] ], [ [ "# SOURCE TXT FILE\nfromfile = \"data/nine_dreams/ninedreams.txt\"\n# TARGET TXT FILE\ntofile = \"data/nine_dreams/ninedreams_utf8.txt\"\nconv_file(fromfile, tofile)\nprint (\"UTF8-CONVERTING DONE\")\nprint (\" [%s] IS GENERATED\" % (tofile))", "UTF8-CONVERTING DONE\n [data/nine_dreams/ninedreams_utf8.txt] IS GENERATED\n" ] ], [ [ "# DECOMPOSE HANGUL (THIS PART IS IMPORTANT!)", "_____no_output_____" ] ], [ [ "def dump_file(filename):\n result=u\"\" # <= UNICODE STRING \n with codecs.open(filename,\"r\", encoding=\"UTF8\") as f:\n for line in f.readlines():\n line = tuple(line)\n result = result + decompose_text(line)\n return result\nprint (\"FUNCTION READY\")", "FUNCTION READY\n" ] ], [ [ "# PYTHON 2 AND 3 COMPATIBILITY", "_____no_output_____" ] ], [ [ "if sys.version_info.major == 2:\n parsed_txt = dump_file(tofile).encode(\"utf8\") \nelse:\n parsed_txt = dump_file(tofile) \n\nprint (\"Parsing %s done\" % (tofile))\n# PRINT FIRST 100 CHARACTERS\nprint (parsed_txt[:100])", "Parsing data/nine_dreams/ninedreams_utf8.txt done\n\n\n ㅎㅏㄴᴥㄱㅜㄱᴥ ㄱㅜㄱᴥㅁㅜㄴᴥㅎㅏㄱᴥㅅㅏᴥㅅㅏㅇᴥ ㅇㅕㅇᴥ�\n" ] ], [ [ "# \"data/nine_dreams/input.txt\" IS GENERATED", "_____no_output_____" ] ], [ [ "with open(\"data/nine_dreams/input.txt\", \"w\") as text_file:\n text_file.write(parsed_txt)\nprint (\"Saved to a txt file\")\nprint (text_file)", "Saved to a txt file\n<closed file 'data/nine_dreams/input.txt', mode 'w' at 0x7f62ae9a58a0>\n" ] ], [ [ "# COMPOSE HANGUL CHARACTER FROM PHONEME ", "_____no_output_____" ] ], [ [ "data=[u'\\u3147', u'\\u3157', u'\\u1d25', u'\\u3134', u'\\u3161', u'\\u3139', u'\\u1d25'\n , u' ', u'\\u314f', u'\\u3147', u'\\u3145', u'\\u314f', u'\\u1d25', u'\\u1d25'\n , u'\\u3163', u'\\u1d25', u' ', u'\\u3147', u'\\u1d25', u'\\u3155', u'\\u1d25'\n , u'\\u3134', u'\\u314f', u'\\u1d25', u'\\u3155', u'\\u3147', u'\\u1d25'\n , u'\\u315b', u'\\u3131', u'\\u1d25', u'\\u3147', u'\\u3139', u'\\u3146'\n , u'\\u1d25', u'\\u3137', u'\\u314f', u'\\u314e', u'\\u3139', u'\\u1d25'\n , u'\\u3134', u'\\u1d25', u'\\u3145', u'\\u3163', u'\\u1d25', u'\\u1d25'\n , u'\\u314f', u'\\u1d25', u'\\u314e', u'\\u314f', u'\\u3147', u'\\u3131'\n , u'\\u3157', u'\\u3134', u'\\u1d25', u'\\u1d25', u'\\u315b', u'\\u1d25'\n , u'\\u3148', u'\\u3153', u'\\u3136', u'\\u1d25', u' ', u'\\u3145', u'\\u3150'\n , u'\\u3141', u'\\u3136', u'\\u3161', u'\\u3134', u'\\u3163', u'\\u1d25', u'.'\n , u'\\u3148', u'\\u3153', u'\\u3134', u'\\u314e', u'\\u3153', u'\\u1d25', u'\\u1d25'\n , u'\\u3147', u'\\u314f', u'\\u3134', u'\\u3148', u'\\u314f', u'\\u3139', u'\\u315d'\n , u'\\u314c', u'\\u1d25', u'\\u3161', u'\\u3134', u'\\u3148', u'\\u3163', u'\\u313a'\n , u'\\u1d25', u' ', u'\\u3147', u'\\u3161', u'\\u3146', u'\\u1d25', u'?', u'\\u3134'\n , u'\\u1d25', u'\\u314e', u'\\u3163', u'\\u1d25', u'\\u3147', u'\\u3148', u'\\u314f'\n ]\nprint automata(\"\".join(data))\n", "오늘 ㅏㅇ사ㅣ ㅇㅕ나ㅕㅇㅛㄱㅇㄹㅆ닿ㄹㄴ시ㅏ항곤ㅛ젆 샘ㄶㅡ니.젆ㅓ앉ㅏ뤝ㅡㄴ짉 읐?ㄴ히ㅇ\n" ] ], [ [ "# GENERATE \"vocab.pkl\" and \"data.npy\" in \"data/nine_dreams/\" FROM \"data/nine_dreams/input.txt\" ", "_____no_output_____" ] ], [ [ "data_dir = \"data/nine_dreams\"\nbatch_size = 50\nseq_length = 50\ndata_loader = TextLoader(data_dir, batch_size, seq_length)", "loading preprocessed files\n" ] ], [ [ "# DATA_LOADER IS:", "_____no_output_____" ] ], [ [ "print ( \"type of 'data_loader' is %s, length is %d\" \n % (type(data_loader.vocab), len(data_loader.vocab)) )", "type of 'data_loader' is <type 'dict'>, length is 76\n" ] ], [ [ "# DATA_LOADER.VOCAB IS:", "_____no_output_____" ] ], [ [ "print (\"data_loader.vocab looks like \\n%s \" % (data_loader.vocab,))", "data_loader.vocab looks like \n{u'_': 69, u'6': 59, u':': 57, u'\\n': 19, u'4': 67, u'5': 63, u'>': 75, u'!': 52, u' ': 1, u'\"': 28, u'\\u1d25': 0, u\"'\": 49, u')': 46, u'(': 45, u'-': 65, u',': 27, u'.': 24, u'\\u3131': 7, u'0': 73, u'\\u3133': 60, u'\\u3132': 29, u'\\u3135': 50, u'\\u3134': 4, u'\\u3137': 13, u'\\u3136': 44, u'\\u3139': 5, u'\\u3138': 32, u'\\u313b': 55, u'\\u313a': 48, u'\\u313c': 54, u'?': 41, u'3': 66, u'\\u3141': 12, u'\\u3140': 51, u'\\u3143': 47, u'\\u3142': 17, u'\\u3145': 10, u'\\u3144': 43, u'\\u3147': 2, u'\\u3146': 22, u'\\u3149': 40, u'\\u3148': 15, u'\\u314b': 42, u'\\u314a': 23, u'\\u314d': 31, u'\\u314c': 30, u'\\u314f': 3, u'\\u314e': 14, u'\\u3151': 34, u'\\u3150': 21, u'\\u3153': 11, u'\\u3152': 74, u'\\u3155': 18, u'\\u3154': 20, u'\\u3157': 9, u'\\u3156': 39, u'\\u3159': 53, u'\\u3158': 26, u'\\u315b': 38, u'\\u315a': 33, u'\\u315d': 36, u'\\u315c': 16, u'\\u315f': 35, u'\\u315e': 61, u'\\u3161': 8, u'\\u3160': 37, u'\\u3163': 6, u'\\u3162': 25, u'\\x1a': 72, u'9': 64, u'7': 71, u'2': 62, u'1': 58, u'\\u313f': 56, u'\\u313e': 70, u'8': 68} \n" ] ], [ [ "# DATA_LOADER.CHARS IS:", "_____no_output_____" ] ], [ [ "print ( \"type of 'data_loader.chars' is %s, length is %d\" \n % (type(data_loader.chars), len(data_loader.chars)) )", "type of 'data_loader.chars' is <type 'tuple'>, length is 76\n" ] ], [ [ "# CHARS CONVERTS INDEX -> CHAR", "_____no_output_____" ] ], [ [ "print (\"data_loader.chars looks like \\n%s \" % (data_loader.chars,))", "data_loader.chars looks like \n(u'\\u1d25', u' ', u'\\u3147', u'\\u314f', u'\\u3134', u'\\u3139', u'\\u3163', u'\\u3131', u'\\u3161', u'\\u3157', u'\\u3145', u'\\u3153', u'\\u3141', u'\\u3137', u'\\u314e', u'\\u3148', u'\\u315c', u'\\u3142', u'\\u3155', u'\\n', u'\\u3154', u'\\u3150', u'\\u3146', u'\\u314a', u'.', u'\\u3162', u'\\u3158', u',', u'\"', u'\\u3132', u'\\u314c', u'\\u314d', u'\\u3138', u'\\u315a', u'\\u3151', u'\\u315f', u'\\u315d', u'\\u3160', u'\\u315b', u'\\u3156', u'\\u3149', u'?', u'\\u314b', u'\\u3144', u'\\u3136', u'(', u')', u'\\u3143', u'\\u313a', u\"'\", u'\\u3135', u'\\u3140', u'!', u'\\u3159', u'\\u313c', u'\\u313b', u'\\u313f', u':', u'1', u'6', u'\\u3133', u'\\u315e', u'2', u'5', u'9', u'-', u'3', u'4', u'8', u'_', u'\\u313e', u'7', u'\\x1a', u'0', u'\\u3152', u'>') \n" ], [ "for i, char in enumerate(data_loader.chars):\n # GET INDEX OF THE CHARACTER\n idx = data_loader.vocab[char]\n print (\"[%02d] %03s (%02d)\" \n % (i, automata(\"\".join(char)), idx))", "[00] (00)\n[01] (01)\n[02] (02)\n[03] ㅏ (03)\n[04] (04)\n[05] (05)\n[06] ㅣ (06)\n[07] (07)\n[08] ㅡ (08)\n[09] ㅗ (09)\n[10] (10)\n[11] ㅓ (11)\n[12] (12)\n[13] (13)\n[14] (14)\n[15] (15)\n[16] ㅜ (16)\n[17] (17)\n[18] ㅕ (18)\n[19] \n (19)\n[20] ㅔ (20)\n[21] ㅐ (21)\n[22] (22)\n[23] (23)\n[24] . (24)\n[25] ㅢ (25)\n[26] ㅘ (26)\n[27] , (27)\n[28] \" (28)\n[29] (29)\n[30] (30)\n[31] (31)\n[32] (32)\n[33] ㅚ (33)\n[34] ㅑ (34)\n[35] ㅟ (35)\n[36] ㅝ (36)\n[37] ㅠ (37)\n[38] ㅛ (38)\n[39] ㅖ (39)\n[40] (40)\n[41] ? (41)\n[42] (42)\n[43] ㅄ (43)\n[44] ㄶ (44)\n[45] ( (45)\n[46] ) (46)\n[47] (47)\n[48] ㄺ (48)\n[49] ' (49)\n[50] ㄵ (50)\n[51] ㅀ (51)\n[52] ! (52)\n[53] ㅙ (53)\n[54] ㄼ (54)\n[55] ㄻ (55)\n[56] ㄿ (56)\n[57] : (57)\n[58] 1 (58)\n[59] 6 (59)\n[60] ㄳ (60)\n[61] ㅞ (61)\n[62] 2 (62)\n[63] 5 (63)\n[64] 9 (64)\n[65] - (65)\n[66] 3 (66)\n[67] 4 (67)\n[68] 8 (68)\n[69] _ (69)\n[70] ㄾ (70)\n[71] 7 (71)\n[72] \u001a (72)\n[73] 0 (73)\n[74] ㅒ (74)\n[75] > (75)\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Command line functions\n\n> Console commands added by the nbdev library", "_____no_output_____" ] ], [ [ "# default_exp cli", "_____no_output_____" ], [ "# export\nfrom nbdev.imports import *\nfrom nbdev.export import *\nfrom nbdev.sync import *\nfrom nbdev.merge import *\nfrom nbdev.export2html import *\nfrom nbdev.test import *\nfrom fastscript import call_parse,Param,bool_arg", "_____no_output_____" ] ], [ [ "`nbdev` comes with the following commands. To use any of them, you muse be in one of the subfolder of your project: they will search for the `settings.ini` recursively in the parent directory but need to accessit to be able to work. Their names all begin by nbdev so you can easily get a list with tab completion.\n- `nbdev_build_lib` builds the library from the notebooks\n- `nbdev_update_lib` propagates any change in the library back to the notebooks\n- `nbdev_diff_nbs` gives you the diff between the notebooks and the exported library\n- `nbdev_build_docs` builds the documentation from the notebooks\n- `nbdev_nb2md` to convert a notebook to a markdown file\n- `nbdev_clean_nbs` removes all superfluous metadata form the notebooks, to avoid merge conflicts\n- `nbdev_read_nbs` read all notebooks to make sure none are broken\n- `nbdev_trust_nbs` trust all notebooks (so that the HTML content is shown)\n- `nbdev_fix_merge` will fix merge conflicts in a notebook file\n- `nbdev_install_git_hooks` install the git hooks that use the last two command automatically on each commit/merge.", "_____no_output_____" ], [ "## Navigating from notebooks to script and back", "_____no_output_____" ] ], [ [ "#export\n@call_parse\ndef nbdev_build_lib(fname:Param(\"A notebook name or glob to convert\", str)=None):\n \"Export notebooks matching `fname` to python modules\"\n write_tmpls()\n notebook2script(fname=fname)", "_____no_output_____" ] ], [ [ "By default (`fname` left to `None`), the whole library is built from the notebooks in the `lib_folder` set in your `settings.ini`.", "_____no_output_____" ] ], [ [ "#export\n@call_parse\ndef nbdev_update_lib(fname:Param(\"A notebook name or glob to convert\", str)=None):\n \"Propagates any change in the modules matching `fname` to the notebooks that created them\"\n script2notebook(fname=fname)", "_____no_output_____" ] ], [ [ "By default (`fname` left to `None`), the whole library is treated. Note that this tool is only designed for small changes such as typo or small bug fixes. You can't add new cells in notebook from the library.", "_____no_output_____" ] ], [ [ "#export\n@call_parse\ndef nbdev_diff_nbs(): \n \"Prints the diff between an export of the library in notebooks and the actual modules\"\n diff_nb_script()", "_____no_output_____" ] ], [ [ "## Extracting tests", "_____no_output_____" ] ], [ [ "# export\ndef _test_one(fname, flags=None, verbose=True):\n print(f\"testing: {fname}\")\n start = time.time()\n try: \n test_nb(fname, flags=flags)\n return True,time.time()-start\n except Exception as e: \n if \"Kernel died before replying to kernel_info\" in str(e):\n time.sleep(random.random())\n _test_one(fname, flags=flags)\n if verbose: print(f'Error in {fname}:\\n{e}')\n return False,time.time()-start", "_____no_output_____" ], [ "# export\n@call_parse\ndef nbdev_test_nbs(fname:Param(\"A notebook name or glob to convert\", str)=None,\n flags:Param(\"Space separated list of flags\", str)=None,\n n_workers:Param(\"Number of workers to use\", int)=None,\n verbose:Param(\"Print errors along the way\", bool)=True,\n timing:Param(\"Timing each notebook to see the ones are slow\", bool)=False):\n \"Test in parallel the notebooks matching `fname`, passing along `flags`\"\n if flags is not None: flags = flags.split(' ')\n if fname is None: \n files = [f for f in Config().nbs_path.glob('*.ipynb') if not f.name.startswith('_')]\n else: files = glob.glob(fname)\n files = [Path(f).absolute() for f in sorted(files)]\n if len(files)==1 and n_workers is None: n_workers=0\n # make sure we are inside the notebook folder of the project\n os.chdir(Config().nbs_path)\n results = parallel(_test_one, files, flags=flags, verbose=verbose, n_workers=n_workers)\n passed,times = [r[0] for r in results],[r[1] for r in results]\n if all(passed): print(\"All tests are passing!\")\n else:\n msg = \"The following notebooks failed:\\n\"\n raise Exception(msg + '\\n'.join([f.name for p,f in zip(passed,files) if not p]))\n if timing:\n for i,t in sorted(enumerate(times), key=lambda o:o[1], reverse=True): \n print(f\"Notebook {files[i].name} took {int(t)} seconds\")", "_____no_output_____" ] ], [ [ "By default (`fname` left to `None`), the whole library is tested from the notebooks in the `lib_folder` set in your `settings.ini`.", "_____no_output_____" ], [ "## Building documentation", "_____no_output_____" ], [ "The following functions complete the ones in `export2html` to fully build the documentation of your library.", "_____no_output_____" ] ], [ [ "#export\nimport time,random,warnings", "_____no_output_____" ], [ "#export\ndef _leaf(k,v):\n url = 'external_url' if \"http\" in v else 'url'\n #if url=='url': v=v+'.html'\n return {'title':k, url:v, 'output':'web,pdf'}", "_____no_output_____" ], [ "#export\n_k_names = ['folders', 'folderitems', 'subfolders', 'subfolderitems']\ndef _side_dict(title, data, level=0):\n k_name = _k_names[level]\n level += 1\n res = [(_side_dict(k, v, level) if isinstance(v,dict) else _leaf(k,v))\n for k,v in data.items()]\n return ({k_name:res} if not title\n else res if title.startswith('empty')\n else {'title': title, 'output':'web', k_name: res})", "_____no_output_____" ], [ "#export\n_re_catch_title = re.compile('^title\\s*:\\s*(\\S+.*)$', re.MULTILINE)", "_____no_output_____" ], [ "#export\ndef _get_title(fname):\n \"Grabs the title of html file `fname`\"\n with open(fname, 'r') as f: code = f.read()\n src = _re_catch_title.search(code)\n return fname.stem if src is None else src.groups()[0]", "_____no_output_____" ], [ "#hide\ntest_eq(_get_title(Config().doc_path/'export.html'), \"Export to modules\")", "_____no_output_____" ], [ "#export\nfrom nbdev.export2html import _nb2htmlfname", "_____no_output_____" ], [ "#export\ndef create_default_sidebar():\n \"Create the default sidebar for the docs website\"\n dic = {\"Overview\": \"/\"}\n files = [f for f in Config().nbs_path.glob('*.ipynb') if not f.name.startswith('_')]\n fnames = [_nb2htmlfname(f) for f in sorted(files)]\n titles = [_get_title(f) for f in fnames if 'index' not in f.stem!='index']\n if len(titles) > len(set(titles)): print(f\"Warning: Some of your Notebooks use the same title ({titles}).\")\n dic.update({_get_title(f):f'/{f.stem}' for f in fnames if f.stem!='index'})\n dic = {Config().lib_name: dic}\n json.dump(dic, open(Config().doc_path/'sidebar.json', 'w'), indent=2)", "_____no_output_____" ] ], [ [ "The default sidebar lists all html pages with their respective title, except the index that is named \"Overview\". To build a custom sidebar, set the flag `custom_sidebar` in your `settings.ini` to `True` then change the `sidebar.json` file in the `doc_folder` to your liking. Otherwise, the sidebar is updated at each doc build.", "_____no_output_____" ] ], [ [ "#hide\n#create_default_sidebar()", "_____no_output_____" ], [ "#export\ndef make_sidebar():\n \"Making sidebar for the doc website form the content of `doc_folder/sidebar.json`\"\n if not (Config().doc_path/'sidebar.json').exists() or Config().custom_sidebar == 'False': create_default_sidebar()\n sidebar_d = json.load(open(Config().doc_path/'sidebar.json', 'r'))\n res = _side_dict('Sidebar', sidebar_d)\n res = {'entries': [res]}\n res_s = yaml.dump(res, default_flow_style=False)\n res_s = res_s.replace('- subfolders:', ' subfolders:').replace(' - - ', ' - ')\n res_s = f\"\"\"\n#################################################\n### THIS FILE WAS AUTOGENERATED! DO NOT EDIT! ###\n#################################################\n# Instead edit {'../../sidebar.json'}\n\"\"\"+res_s\n open(Config().doc_path/'_data/sidebars/home_sidebar.yml', 'w').write(res_s)", "_____no_output_____" ], [ "# export\n_re_index = re.compile(r'^(?:\\d*_|)index\\.ipynb$')", "_____no_output_____" ], [ "# export\ndef make_readme():\n \"Convert the index notebook to README.md\"\n index_fn = None\n for f in Config().nbs_path.glob('*.ipynb'):\n if _re_index.match(f.name): index_fn = f\n assert index_fn is not None, \"Could not locate index notebook\"\n print(f\"converting {index_fn} to README.md\")\n convert_md(index_fn, Config().config_file.parent, jekyll=False)\n n = Config().config_file.parent/index_fn.with_suffix('.md').name\n shutil.move(n, Config().config_file.parent/'README.md')", "_____no_output_____" ], [ "# export\n@call_parse\ndef nbdev_build_docs(fname:Param(\"A notebook name or glob to convert\", str)=None,\n force_all:Param(\"Rebuild even notebooks that haven't changed\", bool)=False,\n mk_readme:Param(\"Also convert the index notebook to README\", bool)=True,\n n_workers:Param(\"Number of workers to use\", int)=None):\n \"Build the documentation by converting notebooks mathing `fname` to html\"\n notebook2html(fname=fname, force_all=force_all, n_workers=n_workers)\n if fname is None: make_sidebar()\n if mk_readme: make_readme()", "_____no_output_____" ] ], [ [ "By default (`fname` left to `None`), the whole documentation is build from the notebooks in the `lib_folder` set in your `settings.ini`, only converting the ones that have been modified since the their corresponding html was last touched unless you pass `force_all=True`. The index is also converted to make the README file, unless you pass along `mk_readme=False`.", "_____no_output_____" ] ], [ [ "# export\n@call_parse\ndef nbdev_nb2md(fname:Param(\"A notebook file name to convert\", str),\n dest:Param(\"The destination folder\", str)='.',\n img_path:Param(\"Folder to export images to\")=\"\",\n jekyll:Param(\"To use jekyll metadata for your markdown file or not\", bool_arg)=False,):\n \"Convert the notebook in `fname` to a markdown file\"\n nb_detach_cells(fname, dest=img_path)\n convert_md(fname, dest, jekyll=jekyll, img_path=img_path)", "_____no_output_____" ], [ "# export\n@call_parse\ndef nbdev_detach(path_nb:Param(\"Path to notebook\"),\n dest:Param(\"Destination folder\", str)=\"\"):\n \"Export cell attachments to `dest` and update references\"\n nb_detach_cells(path_nb, dest=dest)", "_____no_output_____" ] ], [ [ "## Other utils", "_____no_output_____" ] ], [ [ "# export\n@call_parse\ndef nbdev_read_nbs(fname:Param(\"A notebook name or glob to convert\", str)=None):\n \"Check all notebooks matching `fname` can be opened\"\n files = Config().nbs_path.glob('**/*.ipynb') if fname is None else glob.glob(fname)\n for nb in files:\n try: _ = read_nb(nb)\n except Exception as e:\n print(f\"{nb} is corrupted and can't be opened.\")\n raise e", "_____no_output_____" ] ], [ [ "By default (`fname` left to `None`), the all the notebooks in `lib_folder` are checked.", "_____no_output_____" ] ], [ [ "# export\n@call_parse\ndef nbdev_trust_nbs(fname:Param(\"A notebook name or glob to convert\", str)=None,\n force_all:Param(\"Trust even notebooks that haven't changed\", bool)=False):\n \"Trust noteboks matching `fname`\"\n check_fname = Config().nbs_path/\".last_checked\"\n last_checked = os.path.getmtime(check_fname) if check_fname.exists() else None\n files = Config().nbs_path.glob('**/*.ipynb') if fname is None else glob.glob(fname)\n for fn in files:\n if last_checked and not force_all:\n last_changed = os.path.getmtime(fn)\n if last_changed < last_checked: continue\n nb = read_nb(fn)\n if not NotebookNotary().check_signature(nb): NotebookNotary().sign(nb)\n check_fname.touch(exist_ok=True)", "_____no_output_____" ] ], [ [ "By default (`fname` left to `None`), the all the notebooks in `lib_folder` are trusted. To speed things up, only the ones touched since the last time this command was run are trusted unless you pass along `force_all=True`.", "_____no_output_____" ] ], [ [ "# export\n@call_parse\ndef nbdev_fix_merge(fname:Param(\"A notebook filename to fix\", str),\n fast:Param(\"Fast fix: automatically fix the merge conflicts in outputs or metadata\", bool)=True,\n trust_us:Param(\"Use local outputs/metadata when fast mergning\", bool)=True):\n \"Fix merge conflicts in notebook `fname`\"\n fix_conflicts(fname, fast=fast, trust_us=trust_us)", "_____no_output_____" ] ], [ [ "When you have merge conflicts after a `git pull`, the notebook file will be broken and won't open in jupyter notebook anymore. This command fixes this by changing the notebook to a proper json file again and add markdown cells to signal the conflict, you just have to open that notebook again and look for `>>>>>>>` to see those conflicts and manually fix them. The old broken file is copied with a `.ipynb.bak` extension, so is still accessible in case the merge wasn't sucessful.\n\nMoreover, if `fast=True`, conflicts in outputs and metadata will automatically be fixed by using the local version if `trust_us=True`, the remote one if `trust_us=False`. With this option, it's very likely you won't have anything to do, unless there is a real conflict.", "_____no_output_____" ] ], [ [ "#export\ndef bump_version(version, part=2):\n version = version.split('.')\n version[part] = str(int(version[part]) + 1)\n for i in range(part+1, 3): version[i] = '0'\n return '.'.join(version)", "_____no_output_____" ], [ "test_eq(bump_version('0.1.1' ), '0.1.2')\ntest_eq(bump_version('0.1.1', 1), '0.2.0')", "_____no_output_____" ], [ "# export\n@call_parse\ndef nbdev_bump_version(part:Param(\"Part of version to bump\", int)=2):\n \"Increment version in `settings.py` by one\"\n cfg = Config()\n print(f'Old version: {cfg.version}')\n cfg.d['version'] = bump_version(Config().version, part)\n cfg.save()\n update_version()\n print(f'New version: {cfg.version}')", "_____no_output_____" ] ], [ [ "## Git hooks", "_____no_output_____" ] ], [ [ "# export\nimport subprocess", "_____no_output_____" ], [ "# export\n@call_parse\ndef nbdev_install_git_hooks():\n \"Install git hooks to clean/trust notebooks automatically\"\n path = Config().config_file.parent\n fn = path/'.git'/'hooks'/'post-merge'\n #Trust notebooks after merge\n with open(fn, 'w') as f:\n f.write(\"\"\"#!/bin/bash\necho \"Trusting notebooks\"\nnbdev_trust_nbs\n\"\"\"\n )\n os.chmod(fn, os.stat(fn).st_mode | stat.S_IEXEC)\n #Clean notebooks on commit/diff\n with open(path/'.gitconfig', 'w') as f:\n f.write(\"\"\"# Generated by nbdev_install_git_hooks\n#\n# If you need to disable this instrumentation do:\n#\n# git config --local --unset include.path\n#\n# To restore the filter\n#\n# git config --local include.path .gitconfig\n#\n# If you see notebooks not stripped, checked the filters are applied in .gitattributes\n#\n[filter \"clean-nbs\"]\n clean = nbdev_clean_nbs --read_input_stream True\n smudge = cat\n required = true\n[diff \"ipynb\"]\n textconv = nbdev_clean_nbs --disp True --fname\n\"\"\")\n cmd = \"git config --local include.path ../.gitconfig\"\n print(f\"Executing: {cmd}\")\n result = subprocess.run(cmd.split(), shell=False, check=False, stderr=subprocess.PIPE)\n if result.returncode == 0:\n print(\"Success: hooks are installed and repo's .gitconfig is now trusted\")\n else:\n print(\"Failed to trust repo's .gitconfig\")\n if result.stderr: print(f\"Error: {result.stderr.decode('utf-8')}\")\n with open(Config().nbs_path/'.gitattributes', 'w') as f:\n f.write(\"\"\"**/*.ipynb filter=clean-nbs\n**/*.ipynb diff=ipynb\n\"\"\"\n )", "_____no_output_____" ] ], [ [ "This command installs git hooks to make sure notebooks are cleaned before you commit them to GitHub and automatically trusted at each merge. To be more specific, this creates:\n- an executable '.git/hooks/post-merge' file that contains the command `nbdev_trust_nbs`\n- a `.gitconfig` file that uses `nbev_clean_nbs` has a filter/diff on all notebook files inside `nbs_folder` and a `.gitattributes` file generated in this folder (copy this file in other folders where you might have notebooks you want cleaned as well)", "_____no_output_____" ], [ "## Starting a new project", "_____no_output_____" ] ], [ [ "#export\n_template_git_repo = \"https://github.com/fastai/nbdev_template.git\"", "_____no_output_____" ], [ "#export\n@call_parse\ndef nbdev_new(name: Param(\"A directory to create the project in\", str)):\n \"Create a new nbdev project with a given name.\"\n \n path = Path(f\"./{name}\").absolute()\n \n if path.is_dir():\n print(f\"Directory {path} already exists. Aborting.\")\n return\n \n print(f\"Creating a new nbdev project {name}.\")\n \n try:\n subprocess.run(f\"git clone {_template_git_repo} {path}\".split(), check=True, timeout=5000)\n shutil.rmtree(path/\".git\")\n subprocess.run(\"git init\".split(), cwd=path, check=True)\n subprocess.run(\"git add .\".split(), cwd=path, check=True)\n subprocess.run(\"git commit -am \\\"Initial\\\"\".split(), cwd=path, check=True)\n \n print(f\"Created a new repo for project {name}. Please edit settings.ini and run nbdev_build_lib to get started.\")\n except Exception as e:\n print(\"An error occured while copying nbdev project template:\")\n print(e)\n if os.path.isdir(path): shutil.rmtree(path)", "_____no_output_____" ] ], [ [ "`nbdev_new` is a command line tool that creates a new nbdev project based on the [nbdev_template repo](https://github.com/fastai/nbdev_template). It'll initialize a new git repository and commit the new project.\n\nAfter you run `nbdev_new`, please edit `settings.ini` and run `nbdev_build_lib`.", "_____no_output_____" ], [ "## Export", "_____no_output_____" ] ], [ [ "#hide\nfrom nbdev.export import *\nnotebook2script()", "Converted 00_export.ipynb.\nConverted 01_sync.ipynb.\nConverted 02_showdoc.ipynb.\nConverted 03_export2html.ipynb.\nConverted 04_test.ipynb.\nConverted 05_merge.ipynb.\nConverted 06_cli.ipynb.\nConverted 07_clean.ipynb.\nConverted 99_search.ipynb.\nConverted index.ipynb.\nConverted tutorial.ipynb.\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Lecture 01 : intro, inputs, numpy, pandas", "_____no_output_____" ], [ "## 1. Inputs: CSV / Text", "_____no_output_____" ], [ "We will start by ingesting plain text.", "_____no_output_____" ] ], [ [ "from __future__ import print_function\nimport csv", "_____no_output_____" ], [ "my_reader = csv.DictReader(open('data/eu_revolving_loans.csv', 'r'))", "_____no_output_____" ] ], [ [ "DicReader returns a \"generator\" -- which means that we only have 1 chance to read the returning row dictionaries.\n\nLet's just print out line by line to see what we are reading in:", "_____no_output_____" ] ], [ [ "for line in my_reader:\n print(line)", "_____no_output_____" ] ], [ [ "Since the data is tabular format, pandas is ideally suited for such data. There are convenient pandas import functions for reading in tabular data.\n\nPandas provides direct csv ingestion into \"data frames\":", "_____no_output_____" ] ], [ [ "import pandas as pd\ndf = pd.read_csv('data/eu_revolving_loans.csv')\ndf.head()", "_____no_output_____" ] ], [ [ "As we briefly discussed last week, simply reading in without any configuration generates a fairly message data frame. We should try to specify some helping hints to pandas as to where the header rows are and which is the index colum:", "_____no_output_____" ] ], [ [ "df = pd.read_csv('data/eu_revolving_loans.csv', header=[1,2,4], index_col=0)\ndf.head()", "_____no_output_____" ] ], [ [ "## 2. Inputs: Excel", "_____no_output_____" ], [ "Many organizations still use Excel as the common medium for communicating data and analysis. We will look quickly at how to ingest Excel data. There are many packages available to read Excel files. We will use one popular one here.", "_____no_output_____" ] ], [ [ "from __future__ import print_function\nfrom openpyxl import load_workbook", "_____no_output_____" ] ], [ [ "Let's take a look at the excel file that want to read into Jupyter", "_____no_output_____" ] ], [ [ "!open 'data/climate_change_download_0.xlsx'", "_____no_output_____" ] ], [ [ "Here is how we can read the Excel file into the Jupyter environment.", "_____no_output_____" ] ], [ [ "wb = load_workbook(filename='data/climate_change_download_0.xlsx')", "_____no_output_____" ] ], [ [ "What are the \"sheets\" in this workbook?", "_____no_output_____" ] ], [ [ "wb.get_sheet_names()`", "_____no_output_____" ] ], [ [ "We will focus on the sheet 'Data':", "_____no_output_____" ] ], [ [ "ws = wb.get_sheet_by_name('Data')", "_____no_output_____" ] ], [ [ "For the sheet \"Data\", let's print out the content cell-by-cell to view the content.", "_____no_output_____" ] ], [ [ "for row in ws.rows:\n for cell in row:\n print(cell.value)", "_____no_output_____" ] ], [ [ "Pandas also provides direct Excel data ingest:", "_____no_output_____" ] ], [ [ "import pandas as pd\ndf = pd.read_excel('data/climate_change_download_0.xlsx')\ndf.head()", "_____no_output_____" ] ], [ [ "Here is another example with multiple sheets:", "_____no_output_____" ] ], [ [ "df = pd.read_excel('data/GHE_DALY_Global_2000_2012.xls', sheetname='Global2012', header=[4,5])", "_____no_output_____" ] ], [ [ "This dataframe has a \"multi-level\" index:", "_____no_output_____" ] ], [ [ "df.columns", "_____no_output_____" ] ], [ [ "How do we export a dataframe back to Excel?", "_____no_output_____" ] ], [ [ "df.to_excel('data/my_excel.xlsx')", "_____no_output_____" ], [ "!open 'data/my_excel.xlsx'", "_____no_output_____" ] ], [ [ "## 3. Inputs: PDF", "_____no_output_____" ], [ "PDF is also a common communication medium about data and analysis. Let's look at how one can read data from PDF into Python.", "_____no_output_____" ] ], [ [ "import pdftables\n\nmy_pdf = open('data/WEF_GlobalCompetitivenessReport_2014-15.pdf', 'rb')\nchart_page = pdftables.get_pdf_page(my_pdf, 29)", "_____no_output_____" ] ], [ [ "PDF is a proprietary file format with specific tagging that has been reverse engineered. Let's take a look at some structures in this file.", "_____no_output_____" ] ], [ [ "table = pdftables.page_to_tables(chart_page)\ntitles = zip(table[0][0], table[0][1])[:5]\ntitles = [''.join([title[0], title[1]]) for title in titles]\nprint(titles)", "_____no_output_____" ] ], [ [ "There is a table with structured data that we can peel out:", "_____no_output_____" ] ], [ [ "all_rows = []\nfor row_data in table[0][2:]:\n all_rows.extend([row_data[:5], row_data[5:]])\n\nprint(all_rows)", "_____no_output_____" ] ], [ [ "## 4. Configurations", "_____no_output_____" ] ], [ [ "from ConfigParser import ConfigParser\nconfig = ConfigParser()\nconfig.read('../cfg/sample.cfg')", "_____no_output_____" ], [ "config.sections()", "_____no_output_____" ] ], [ [ "## 5. APIs", "_____no_output_____" ], [ "### Getting Twitter data from API\n\nRelevant links to the exercise here:\n\n- Twitter Streaming: https://dev/twitter.com/streaming/overview\n- API client: https://github.com/tweepy/tweepy\n- Twitter app: https://apps.twitter.com\n", "_____no_output_____" ], [ "#### Create an authentication handler", "_____no_output_____" ] ], [ [ "import tweepy\nauth = tweepy.OAuthHandler(config.get('twitter', 'consumer_key'), config.get('twitter', 'consumer_secret'))\nauth.set_access_token(config.get('twitter','access_token'), config.get('twitter','access_token_secret'))\nauth", "_____no_output_____" ] ], [ [ "#### Create an API endpoint", "_____no_output_____" ] ], [ [ "api = tweepy.API(auth)", "_____no_output_____" ] ], [ [ "#### Try REST-ful API call to Twitter", "_____no_output_____" ] ], [ [ "python_tweets = api.search('turkey')", "_____no_output_____" ], [ "for tweet in python_tweets:\n print(tweet.text)", "_____no_output_____" ] ], [ [ "#### For streaming API call, we should run a standalone python program: tweetering.py", "_____no_output_____" ], [ "### Input & Output to OpenWeatherMap API\n\nRelevant links to the exercise here:\n\n- http://openweathermap.org/\n- http://openweathermap.org/current\n\nAPI call:\n\n```\napi.openweathermap.org/data/2.5/weather?q={city name}\n\napi.openweathermap.org/data/2.5/weather?q={city name},{country code}\n```\n\nParameters:\n\n> q city name and country code divided by comma, use ISO 3166 country codes\n\nExamples of API calls:\n```\napi.openweathermap.org/data/2.5/weather?q=London\n\napi.openweathermap.org/data/2.5/weather?q=London,uk\n```", "_____no_output_____" ] ], [ [ "from pprint import pprint\nimport requests\nweather_key = config.get('openweathermap', 'api_key')\nres = requests.get(\"http://api.openweathermap.org/data/2.5/weather\",\n params={\"q\": \"San Francisco\", \"appid\": weather_key, \"units\": \"metric\"})", "_____no_output_____" ], [ "pprint(res.json())", "_____no_output_____" ] ], [ [ "## 6. Python requests", "_____no_output_____" ], [ "\"requests\" is a wonderful HTTP library for Python, with the right level of abstraction to avoid lots of tedious plumbing (manually add query strings to your URLs, or to form-encode your POST data). Keep-alive and HTTP connection pooling are 100% automatic, powered by urllib3, which is embedded within Requests)\n\n```\n>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))\n>>> r.status_code\n200\n>>> r.headers['content-type']\n'application/json; charset=utf8'\n>>> r.encoding\n'utf-8'\n>>> r.text\nu'{\"type\":\"User\"...'\n>>> r.json()\n{u'private_gists': 419, u'total_private_repos': 77, ...}\n```\n\nThere is a lot of great documentation at the python-requests [site](http://docs.python-requests.org/en/master/) -- we are extracting selected highlights from there for your convenience here.\n\n### Making a request\n\nMaking a request with Requests is very simple.\n\nBegin by importing the Requests module:", "_____no_output_____" ] ], [ [ "import requests", "_____no_output_____" ] ], [ [ "Now, let's try to get a webpage. For this example, let's get GitHub's public timeline", "_____no_output_____" ] ], [ [ "r = requests.get('https://api.github.com/events')", "_____no_output_____" ] ], [ [ "Now, we have a Response object called r. We can get all the information we need from this object.\n\nRequests' simple API means that all forms of HTTP request are as obvious. For example, this is how you make an HTTP POST request:\n", "_____no_output_____" ] ], [ [ "r = requests.post('http://httpbin.org/post', data = {'key':'value'})", "_____no_output_____" ] ], [ [ "What about the other HTTP request types: PUT, DELETE, HEAD and OPTIONS? These are all just as simple:", "_____no_output_____" ] ], [ [ "r = requests.put('http://httpbin.org/put', data = {'key':'value'})\nr = requests.delete('http://httpbin.org/delete')\nr = requests.head('http://httpbin.org/get')\nr = requests.options('http://httpbin.org/get')", "_____no_output_____" ] ], [ [ "### Passing Parameters In URLs\n\nYou often want to send some sort of data in the URL's query string. If you were constructing the URL by hand, this data would be given as key/value pairs in the URL after a question mark, e.g. httpbin.org/get?key=val. Requests allows you to provide these arguments as a dictionary, using the params keyword argument. As an example, if you wanted to pass key1=value1 and key2=value2 to httpbin.org/get, you would use the following code:", "_____no_output_____" ] ], [ [ "payload = {'key1': 'value1', 'key2': 'value2'}\nr = requests.get('http://httpbin.org/get', params=payload)", "_____no_output_____" ] ], [ [ "You can see that the URL has been correctly encoded by printing the URL:", "_____no_output_____" ] ], [ [ "print(r.url)", "_____no_output_____" ] ], [ [ "Note that any dictionary key whose value is None will not be added to the URL's query string.\n\nYou can also pass a list of items as a value:", "_____no_output_____" ] ], [ [ "payload = {'key1': 'value1', 'key2': ['value2', 'value3']}\n\nr = requests.get('http://httpbin.org/get', params=payload)\nprint(r.url)", "_____no_output_____" ] ], [ [ "### Response Content\n\nWe can read the content of the server's response. Consider the GitHub timeline again:", "_____no_output_____" ] ], [ [ "import requests\n\nr = requests.get('https://api.github.com/events')\nr.text", "_____no_output_____" ] ], [ [ "Requests will automatically decode content from the server. Most unicode charsets are seamlessly decoded.\n\nWhen you make a request, Requests makes educated guesses about the encoding of the response based on the HTTP headers. The text encoding guessed by Requests is used when you access r.text. You can find out what encoding Requests is using, and change it, using the r.encoding property:", "_____no_output_____" ] ], [ [ "r.encoding", "_____no_output_____" ], [ "r.encoding = 'ISO-8859-1'", "_____no_output_____" ] ], [ [ "If you change the encoding, Requests will use the new value of r.encoding whenever you call r.text. You might want to do this in any situation where you can apply special logic to work out what the encoding of the content will be. For example, HTTP and XML have the ability to specify their encoding in their body. In situations like this, you should use r.content to find the encoding, and then set r.encoding. This will let you use r.text with the correct encoding.\n\nRequests will also use custom encodings in the event that you need them. If you have created your own encoding and registered it with the codecs module, you can simply use the codec name as the value of r.encoding and Requests will handle the decoding for you.", "_____no_output_____" ], [ "### JSON Response Content\n\nThere's also a builtin JSON decoder, in case you're dealing with JSON data:", "_____no_output_____" ] ], [ [ "import requests\n\nr = requests.get('https://api.github.com/events')\nr.json()", "_____no_output_____" ] ], [ [ "In case the JSON decoding fails, r.json raises an exception. For example, if the response gets a 204 (No Content), or if the response contains invalid JSON, attempting r.json raises ValueError: No JSON object could be decoded.\n\nIt should be noted that the success of the call to r.json does not indicate the success of the response. Some servers may return a JSON object in a failed response (e.g. error details with HTTP 500). Such JSON will be decoded and returned. To check that a request is successful, use r.raise_for_status() or check r.status_code is what you expect.", "_____no_output_____" ] ], [ [ "r.status_code", "_____no_output_____" ] ], [ [ "### Custom Headers\nIf you'd like to add HTTP headers to a request, simply pass in a dict to the headers parameter.\n\nFor example, we didn't specify our user-agent in the previous example:", "_____no_output_____" ] ], [ [ "url = 'https://api.github.com/some/endpoint'\nheaders = {'user-agent': 'my-app/0.0.1'}\n\nr = requests.get(url, headers=headers)", "_____no_output_____" ] ], [ [ "Note: Custom headers are given less precedence than more specific sources of information. For instance:\n\n- Authorization headers set with headers= will be overridden if credentials are specified in .netrc, which in turn will be overridden by the auth= parameter.\n- Authorization headers will be removed if you get redirected off-host.\n- Proxy-Authorization headers will be overridden by proxy credentials provided in the URL.\n- Content-Length headers will be overridden when we can determine the length of the content.", "_____no_output_____" ], [ "### Response Headers\nWe can view the server's response headers using a Python dictionary:", "_____no_output_____" ] ], [ [ "r.headers", "_____no_output_____" ] ], [ [ "The dictionary is special, though: it's made just for HTTP headers. According to RFC 7230, HTTP Header names are case-insensitive.\n\nSo, we can access the headers using any capitalization we want:", "_____no_output_____" ] ], [ [ "r.headers['Content-Type']", "_____no_output_____" ], [ "r.headers.get('content-type')", "_____no_output_____" ] ], [ [ "### Cookies\nIf a response contains some Cookies, you can quickly access them:\n", "_____no_output_____" ] ], [ [ "url = 'http://www.cnn.com'\nr = requests.get(url)\nprint(r.cookies.items())", "_____no_output_____" ] ], [ [ "To send your own cookies to the server, you can use the cookies parameter:", "_____no_output_____" ] ], [ [ "url = 'http://httpbin.org/cookies'\ncookies = dict(cookies_are='working')\nr = requests.get(url, cookies=cookies)\nr.text\n", "_____no_output_____" ] ], [ [ "### Redirection and History\nBy default Requests will perform location redirection for all verbs except HEAD.\n\nWe can use the history property of the Response object to track redirection.\n\nThe Response.history list contains the Response objects that were created in order to complete the request. The list is sorted from the oldest to the most recent response.\n\nFor example, GitHub redirects all HTTP requests to HTTPS:\n", "_____no_output_____" ] ], [ [ "r = requests.get('http://github.com')\nr.url", "_____no_output_____" ], [ "r.status_code", "_____no_output_____" ], [ "r.history", "_____no_output_____" ] ], [ [ "If you're using GET, OPTIONS, POST, PUT, PATCH or DELETE, you can disable redirection handling with the allow_redirects parameter:", "_____no_output_____" ] ], [ [ "r = requests.get('http://github.com', allow_redirects=False)\n\nr.status_code", "_____no_output_____" ], [ "r.history", "_____no_output_____" ] ], [ [ "If you're using HEAD, you can enable redirection as well:", "_____no_output_____" ] ], [ [ "r = requests.head('http://github.com', allow_redirects=True)\nr.url", "_____no_output_____" ], [ "r.history", "_____no_output_____" ] ], [ [ "### Timeouts\nYou can tell Requests to stop waiting for a response after a given number of seconds with the timeout parameter:", "_____no_output_____" ] ], [ [ "requests.get('http://github.com', timeout=1)", "_____no_output_____" ] ], [ [ "> Note\n> ----\n> timeout is not a time limit on the entire response download; rather, an exception is raised if the server has not issued a response for timeout seconds (more precisely, if no bytes have been received on the underlying socket for timeout seconds).", "_____no_output_____" ], [ "### Errors and Exceptions\nIn the event of a network problem (e.g. DNS failure, refused connection, etc), Requests will raise a ConnectionError exception.\n\nResponse.raise_for_status() will raise an HTTPError if the HTTP request returned an unsuccessful status code.\n\nIf a request times out, a Timeout exception is raised.\n\nIf a request exceeds the configured number of maximum redirections, a TooManyRedirects exception is raised.\n\nAll exceptions that Requests explicitly raises inherit from requests.exceptions.RequestException.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# IPL_Sport_Analysis\n\nTask - 3\n", "_____no_output_____" ], [ "# Introduction", "_____no_output_____" ], [ "The Indian Premier League (IPL),is a professional Twenty20 \ncricket league in India contested during April and May of \nevery year by teams representing Indian cities. The league \nwas founded by the Board of Control for Cricket in India (BCCI) \nin 2007. The IPL is the most-attended cricket league in the world \nand ranks sixth among all sports league.", "_____no_output_____" ], [ "The data consists of two datasets : matches and deliveries.", "_____no_output_____" ], [ "matches dataset contains data of all IPL matches.\n\ndeliveries dataset contains ball by ball data of each IPL match.", "_____no_output_____" ], [ "# Objective", "_____no_output_____" ], [ "Aim is to provide some interesting insights by analyzing the IPL data.", "_____no_output_____" ] ], [ [ "## Importing Required Libraries\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport warnings\nwarnings.filterwarnings('ignore')\n%matplotlib inline", "C:\\Users\\hp\\Anaconda3\\lib\\site-packages\\statsmodels\\tools\\_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n import pandas.util.testing as tm\n" ], [ "## function to add data to plot\ndef annot_plot(ax,w,h):\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n for p in ax.patches:\n ax.annotate('{}'.format(p.get_height()), (p.get_x()+w, p.get_height()+h))", "_____no_output_____" ] ], [ [ "# Reading Data", "_____no_output_____" ] ], [ [ "match_data=pd.read_csv('matches.csv')\ndeliveries_data=pd.read_csv('deliveries.csv')", "_____no_output_____" ], [ "season_data=match_data[['id','season','winner']]\n\ncomplete_data=deliveries_data.merge(season_data,how='inner',left_on='match_id',right_on='id')", "_____no_output_____" ], [ "match_data.head()", "_____no_output_____" ], [ "match_data['win_by']=np.where(match_data['win_by_runs']>0,'Bat first','Bowl first')", "_____no_output_____" ], [ "match_data.shape", "_____no_output_____" ], [ "deliveries_data.head(5)", "_____no_output_____" ], [ "deliveries_data['runs']=deliveries_data['total_runs'].cumsum()", "_____no_output_____" ], [ "deliveries_data.shape", "_____no_output_____" ] ], [ [ "# Number of Matches played in each IPL season", "_____no_output_____" ] ], [ [ "ax=sns.countplot('season',data=match_data,palette=\"Set2\")\nplt.ylabel('Matches')\nannot_plot(ax,0.08,1)", "_____no_output_____" ] ], [ [ "# Matches Won By the Teams", "_____no_output_____" ], [ "Mumbai Indians won maximum number of matches followed by Chennai Super Kings.", "_____no_output_____" ] ], [ [ "match_data.groupby('winner')['winner'].agg(\n['count']).sort_values('count').reset_index().plot(x='winner',y='count',kind='barh')", "_____no_output_____" ], [ "ax=sns.countplot(x='winner',data=match_data)\nplt.ylabel('Match')\nplt.xticks(rotation=80)\nannot_plot(ax,0.05,1)", "_____no_output_____" ] ], [ [ "# Win Percentage", "_____no_output_____" ] ], [ [ "match=match_data.win_by.value_counts()\nlabels=np.array(match.index)\nsizes = match.values\ncolors = ['gold', 'lightskyblue']\n \n# Plot\nplt.pie(sizes, labels=labels, colors=colors,\n autopct='%1.1f%%', shadow=True,startangle=90)\n\nplt.title('Match Result')\nplt.axis('equal')\nplt.show()", "_____no_output_____" ], [ "sns.countplot('season',hue='win_by',data=match_data,palette=\"Set1\")", "_____no_output_____" ] ], [ [ "# Toss Decisions so far", "_____no_output_____" ] ], [ [ "toss=match_data.toss_decision.value_counts()\nlabels=np.array(toss.index)\nsizes = toss.values\ncolors = ['red', 'gold']\n#explode = (0.1, 0, 0, 0) # explode 1st slice\n \n# Plot\nplt.pie(sizes, labels=labels, colors=colors,\n autopct='%1.1f%%', shadow=True,startangle=90)\n\nplt.title('Toss Result')\nplt.axis('equal')\nplt.show()", "_____no_output_____" ], [ "sns.countplot('season',hue='toss_decision',data=match_data,palette=\"Set2\")", "_____no_output_____" ] ], [ [ "# IPL Winners", "_____no_output_____" ] ], [ [ "final_matches=match_data.drop_duplicates(subset=['season'], keep='last')\n\nfinal_matches[['season','winner']].reset_index(drop=True).sort_values('season')", "_____no_output_____" ] ], [ [ "# IPL Finals", "_____no_output_____" ], [ "IPL Finals venues and winners along with the number of wins.", "_____no_output_____" ] ], [ [ "final_matches.groupby(['city','winner']).size()", "_____no_output_____" ] ], [ [ "# Number of IPL seasons won by teams", "_____no_output_____" ] ], [ [ "final_matches['winner'].value_counts()", "_____no_output_____" ] ], [ [ "# Win Percentage in Finals", "_____no_output_____" ] ], [ [ "match=final_matches.win_by.value_counts()\nlabels=np.array(match.index)\nsizes = match.values\ncolors = ['gold', 'lightskyblue']\n \n# Plot\nplt.pie(sizes, labels=labels, colors=colors,\n autopct='%1.1f%%', shadow=True,startangle=90)\n\nplt.title('Match Result')\nplt.axis('equal')\nplt.show()", "_____no_output_____" ] ], [ [ "# Toss Decision in Finals", "_____no_output_____" ] ], [ [ "toss=final_matches.toss_decision.value_counts()\nlabels=np.array(toss.index)\nsizes = toss.values\ncolors = ['gold', 'lightskyblue']\n#explode = (0.1, 0, 0, 0) # explode 1st slice\n \n# Plot\nplt.pie(sizes, labels=labels, colors=colors,\n autopct='%1.1f%%', shadow=True,startangle=90)\n\nplt.title('Toss Result')\nplt.axis('equal')\nplt.show()", "_____no_output_____" ], [ "final_matches[['toss_winner','toss_decision','winner']].reset_index(drop=True)", "_____no_output_____" ] ], [ [ "# Man of the Match in final match", "_____no_output_____" ] ], [ [ "final_matches[['winner','player_of_match']].reset_index(drop=True)", "_____no_output_____" ], [ "len(final_matches[final_matches['toss_winner']==final_matches['winner']]['winner'])", "_____no_output_____" ] ], [ [ "# IPL leading Run Scorer¶\nSuresh Raina is at the top with 4548 Runs. There are 3 foreign players in this list. Among them Chris Gayle is the leading run scorer.", "_____no_output_____" ] ], [ [ "batsman_score=deliveries_data.groupby('batsman')['batsman_runs'].\nagg(['sum']).reset_index().sort_values('sum',ascending=False).reset_index(drop=True)\nbatsman_score=batsman_score.rename(columns={'sum':'batsman_runs'})\nprint(\"*** Top 10 Leading Run Scorer in IPL ***\")\nbatsman_score.iloc[:10,:]", "*** Top 10 Leading Run Scorer in IPL ***\n" ], [ "No_Matches_player_dismissed = deliveries_data[[\"match_id\",\"player_dismissed\"]]\nNo_Matches_player_dismissed =No_Matches_player_dismissed .groupby(\"player_dismissed\")[\"match_id\"].count().reset_index().sort_values(by=\"match_id\",ascending=False).reset_index(drop=True)\nNo_Matches_player_dismissed.columns=[\"batsman\",\"No_of Matches\"]\nNo_Matches_player_dismissed .head(5)", "_____no_output_____" ] ], [ [ "# Batting Average", "_____no_output_____" ] ], [ [ "Batsman_Average=pd.merge(batsman_score,No_Matches_player_dismissed ,on=\"batsman\")\n#merging the score and match played by batsman\nBatsman_Average=Batsman_Average[Batsman_Average[\"batsman_runs\"]>=500]\n# taking Average for those player for having more than 500 runs under thier belt\nBatsman_Average[\"Average\"]=Batsman_Average[\"batsman_runs\"]/Batsman_Average[\"No_of Matches\"]\nBatsman_Average['Average']=Batsman_Average['Average'].apply(lambda x: round(x,2))\nBatsman_Average=Batsman_Average.sort_values(by=\"Average\",ascending=False).reset_index(drop=True)\n\ntop_bat_avg=Batsman_Average.iloc[:10,:]\nax=top_bat_avg.plot('batsman','Average',color='green',kind='bar')\nplt.ylabel('Average')\nplt.xticks(rotation=80)\nannot_plot(ax,0,1)", "_____no_output_____" ] ], [ [ "Amla is at the top of this list with the batting average of 44.38.", "_____no_output_____" ], [ "# Dismissals in IPL", "_____no_output_____" ] ], [ [ "plt.figure(figsize=(12,6))\nax=sns.countplot(deliveries_data.dismissal_kind)\nplt.xticks(rotation=90)\nannot_plot(ax,0.2,100)", "_____no_output_____" ] ], [ [ "# Dismissal by Teams and their distribution", "_____no_output_____" ] ], [ [ "out=deliveries_data.groupby(['batting_team','dismissal_kind'])['dismissal_kind'].agg(['count'])\n\nout.groupby(level=0).apply(lambda x: round(100 * x / float(x.sum()),2)).reset_index().sort_values(['batting_team','count'],ascending=[1,0]).set_index(['batting_team','dismissal_kind'])", "_____no_output_____" ], [ "wicket_data=deliveries_data.dropna(subset=['dismissal_kind'])", "_____no_output_____" ], [ "wicket_data=wicket_data[~wicket_data['dismissal_kind'].isin(['run out','retired hurt','obstructing the field'])]", "_____no_output_____" ] ], [ [ "# IPL Most Wicket-Taking Bowlers", "_____no_output_____" ] ], [ [ "wicket_data.groupby('bowler')['dismissal_kind'].agg(['count']).reset_index().sort_values('count',ascending=False).reset_index(drop=True).iloc[:10,:]", "_____no_output_____" ] ], [ [ "Malinga is at the top of this list with 170 wickets", "_____no_output_____" ], [ "# Powerplays", "_____no_output_____" ], [ "In IPL the Powerplay consists of first 6 overs.\n\nDuring the first six overs, a maximum of two fielders can be outside the 30-yard circle.", "_____no_output_____" ] ], [ [ "powerplay_data=complete_data[complete_data['over']<=6]", "_____no_output_____" ] ], [ [ "# Runs in Powerplays", "_____no_output_____" ] ], [ [ "powerplay_data[ powerplay_data['inning']==1].groupby('match_id')['total_runs'].agg(['sum']).reset_index().plot(x='match_id',y='sum',title='Batting First')\npowerplay_data[ powerplay_data['inning']==2].groupby('match_id')['total_runs'].agg(['sum']).reset_index().plot(x='match_id',y='sum',title='Batting Second')", "_____no_output_____" ] ], [ [ "# Higgest Runs in PowerPlays", "_____no_output_____" ] ], [ [ "powerplay_data.groupby(['season','match_id','inning'])['total_runs'].agg(['sum']).reset_index().groupby('season')['sum'].max()", "_____no_output_____" ] ], [ [ "# Highest Runs in Powerplay :Batting First", "_____no_output_____" ] ], [ [ "pi1=powerplay_data[ powerplay_data['inning']==1].groupby(['season','match_id'])['total_runs'].agg(['sum'])\npi1.reset_index().groupby('season')['sum'].max()\n", "_____no_output_____" ] ], [ [ "# Highest Runs in Powerplay :Batting Second", "_____no_output_____" ] ], [ [ "pi2=powerplay_data[ powerplay_data['inning']==2].groupby(['season','match_id'])['total_runs'].agg(['sum'])\n\npi2.reset_index().groupby('season')['sum'].max()", "_____no_output_____" ] ], [ [ "# Maximum Wickets Fall in PowerPlay", "_____no_output_____" ] ], [ [ "powerplay_data.dropna(subset=['dismissal_kind']).groupby(['season','match_id','inning'])['dismissal_kind'].agg(['count']).reset_index().groupby('season')['count'].max()", "_____no_output_____" ] ], [ [ "# First Innings", "_____no_output_____" ] ], [ [ "powerplay_data[ powerplay_data['inning']==1].dropna(\n subset=['dismissal_kind']).groupby(\n ['season','match_id','inning'])['dismissal_kind'].agg(['count']).reset_index().groupby('season')['count'].max()\n", "_____no_output_____" ] ], [ [ "# Second Innings", "_____no_output_____" ] ], [ [ "powerplay_data[ powerplay_data['inning']==2].dropna(\n subset=['dismissal_kind']).groupby(['season','match_id','inning'])['dismissal_kind'].agg(\n ['count']).reset_index().groupby('season')['count'].max()", "_____no_output_____" ] ], [ [ "# Thank you", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# HIERARCHICAL CLUSTERING\n**File:** hierarchical.ipynb\n\n**Course:** Data Science Foundations: Data Mining in Python", "_____no_output_____" ], [ "# IMPORT LIBRARIES", "_____no_output_____" ] ], [ [ "import pandas as pd # For dataframes\nimport matplotlib.pyplot as plt # For plotting data\nimport seaborn as sns # For plotting data\nfrom sklearn.cluster import AgglomerativeClustering # For clustering\nfrom scipy.cluster.hierarchy import dendrogram, linkage # For clustering and visualization", "_____no_output_____" ] ], [ [ "# LOAD AND PREPARE DATA\nRead the `penguins.csv` file from the `data` directory into variable `df`. Select a random sample of 75 cases of the dataset for easy visualization. Keep all features in variable `df` and store the class variable in `y`.", "_____no_output_____" ] ], [ [ "# Reads the .csv file into variable df\ndf = pd.read_csv('data/penguins.csv')\n\n# Selects a random sample of 75 cases\ndf = df.sample(n=75, random_state=1)\n\n# Separates the class variable in y\ny = df.y\n\n# Removes the y column from df\ndf = df.drop('y', axis=1)\n\n# Displays the first 5 rows of df\ndf.head()", "_____no_output_____" ] ], [ [ "# HIERARCHICAL CLUSTERING \nIn this demonstration, we'll use `SciPy` to perform hierarchical clustering. (Another common choice is `scikit-learn`.)\n\nThe `scipy.cluster.hierarchy` package contains two functions, i.e., `linkage()` and `dendogram()` for hierarchical clustering. The `linkage()` function performs agglomerative clustering and the `dendogram()` function displays the clusters. Various `linkage` methods are possible. Here we'll use the `ward` linkage method that merges clusters so that variance of the clusters is minimized. Other linkage options are:\n\n- `average`\n- `single` \n- `complete` \n\nThe `linkage()` function returns a linkage matrix with information about clusters. This matrix can be viewed using the `dendogram()` function. The code below performs clustering using the `euclidean` metric and displays the clusters.", "_____no_output_____" ] ], [ [ "# Performs agglomerative clustering using `ward` linkage and `euclidean` metric\nhc = linkage(df, method='ward', metric='euclidean')\n\n# Sets the figure size\nfig = plt.figure(figsize=(15, 15))\n\n# Displays the dendogram\n# The lambda function sets the labels of each leaf\ndn = dendrogram(\n hc,\n leaf_label_func=lambda id: y.values[id],\n leaf_font_size=10)", "_____no_output_____" ] ], [ [ "# CLEAN UP\n\n- If desired, clear the results with Cell > All Output > Clear. \n- Save your work by selecting File > Save and Checkpoint.\n- Shut down the Python kernel and close the file by selecting File > Close and Halt.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import pandas as pd\nimport numpy as np\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport nltk", "_____no_output_____" ], [ "data = pd.read_json('https://raw.githubusercontent.com/risan/quran-json/master/json/translations/id.pretty.json')", "_____no_output_____" ], [ "data", "_____no_output_____" ], [ "data.drop(['surah_number'],axis=1,inplace=True)", "_____no_output_____" ], [ "data", "_____no_output_____" ], [ "data.rename(columns={'content':'translation'},inplace=True)", "_____no_output_____" ], [ "data", "_____no_output_____" ], [ "data.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 6236 entries, 0 to 6235\nData columns (total 2 columns):\nverse_number 6236 non-null int64\ntranslation 6236 non-null object\ndtypes: int64(1), object(1)\nmemory usage: 97.6+ KB\n" ], [ "data.to_json('DATAMAINING2020/Indonesia.json')", "_____no_output_____" ], [ "data.to_csv('DATAMAINING2020/Indonesia.csv',index=False)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Dependencies\nimport numpy as np\nimport pandas as pd\n\n# Python SQL toolkit and Object Relational Mapper\nimport sqlalchemy\nfrom sqlalchemy.ext.automap import automap_base\nfrom sqlalchemy.orm import Session\nfrom sqlalchemy import create_engine, func", "_____no_output_____" ], [ "engine = create_engine(\"sqlite:///hawaii.sqlite\")\n\n# reflect an existing database into a new model\nBase = automap_base()\n# reflect the tables\nBase.prepare(engine, reflect=True)\n\n# Save references to each table\nMeasurement = Base.classes.measurement\nStation = Base.classes.station", "_____no_output_____" ], [ "# Create our session (link) from Python to the DB\nsession = Session(engine)", "_____no_output_____" ] ], [ [ "## D1: Determine the Summary Statistics for June", "_____no_output_____" ] ], [ [ "# 1. Import the sqlalchemy extract function.\nfrom sqlalchemy import extract\n\n# 2. Write a query that filters the Measurement table to retrieve the temperatures for the month of June. \njune_temps = session.query(Measurement.date, Measurement.tobs).\\\nfilter(func.strftime(\"%m\", Measurement.date) == \"06\")\n\n ", "_____no_output_____" ], [ "# 3. Convert the June temperatures to a list.\njune_temps = session.query(Measurement.date, Measurement.tobs).\\\nfilter(func.strftime(\"%m\", Measurement.date) == \"06\").all()\njune_temps", "_____no_output_____" ], [ "# 4. Create a DataFrame from the list of temperatures for the month of June. \ndf = pd.DataFrame(june_temps, columns=['date', 'June temperature'])", "_____no_output_____" ], [ "# 5. Calculate and print out the summary statistics for the June temperature DataFrame.\ndf.describe()", "_____no_output_____" ], [ "#Calculate precipitation for June and put into list\njune_prcp = session.query(Measurement.date, Measurement.prcp).\\\nfilter(func.strftime(\"%m\", Measurement.date) == \"06\").all()", "_____no_output_____" ], [ "df = pd.DataFrame(june_prcp, columns=['date', 'June precipitation'])", "_____no_output_____" ], [ "df.describe()", "_____no_output_____" ] ], [ [ "## D2: Determine the Summary Statistics for December", "_____no_output_____" ] ], [ [ "# 6. Write a query that filters the Measurement table to retrieve the temperatures for the month of December.\ndec_temps = session.query(Measurement.date, Measurement.tobs).\\\nfilter(func.strftime(\"%m\", Measurement.date) == \"12\")", "_____no_output_____" ], [ "# 7. Convert the December temperatures to a list.\ndec_temps = session.query(Measurement.date, Measurement.tobs).\\\nfilter(func.strftime(\"%m\", Measurement.date) == \"12\").all()", "_____no_output_____" ], [ "# 8. Create a DataFrame from the list of temperatures for the month of December. \ndf = pd.DataFrame(dec_temps, columns=['date', 'December temperature'])", "_____no_output_____" ], [ "# 9. Calculate and print out the summary statistics for the Decemeber temperature DataFrame.\ndf.describe()", "_____no_output_____" ], [ "#Calculate precipitation for December and put into list\ndec_prcp = session.query(Measurement.date, Measurement.prcp).\\\nfilter(func.strftime(\"%m\", Measurement.date) == \"12\").all()", "_____no_output_____" ], [ "#Create a DataFrame for December precipitation\ndf = pd.DataFrame(dec_prcp, columns=['date', 'December precipitation'])", "_____no_output_____" ], [ "df.describe()", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Simulation of diffusion with noise", "_____no_output_____" ], [ "## Package imports", "_____no_output_____" ] ], [ [ "import numpy as np\nimport numpy.random as npr\nfrom scipy.signal import convolve2d\nimport matplotlib.pyplot as plt\nfrom matplotlib.animation import FuncAnimation\nfrom IPython.display import HTML", "_____no_output_____" ] ], [ [ "## Settings", "_____no_output_____" ] ], [ [ "# Number of timesteps to simulate\nduration = 500\n\n# Dimension of simulation domain\nn = 100\n\n# Sampling time\ndt = 0.1\n\n# Initialize the state and noise\nstate = npr.rand(n, n)\nnoise = np.zeros([n, n])\n\n# Define the diffusion rate - ensure rate*dt < 0.25 for numerical stability using Euler integration\nrate = 2.0\n\n# Define the force and noise amount\nforce_amount = 0.005\nnoise_amount = 0.040\n\n# Define the force frequency\nforce_freq = 0.001\n\n# Define the noise inertia (between 0 and 1, 0 is fully white noise, 1 is a constant signal)\nnoise_inertia = 0.9", "_____no_output_____" ] ], [ [ "## Simulation", "_____no_output_____" ] ], [ [ "# Compute the convolution kernel for diffusion dynamics\ndiffusion_kernel = np.array([[ 0, rate, 0],\n [rate, -4*rate, rate],\n [ 0, rate, 0]])\n# Compute the force kernel\ns = np.linspace(-1, 1, n)\nx, y = np.meshgrid(s, s)\nforce_kernel = x**2 + y**2 < 0.2\n\n\ndef physics_update(state, noise, t):\n # Linear diffusion dynamics using Euler integration\n state = state + dt*convolve2d(state, diffusion_kernel, mode='same', boundary='wrap')\n\n # Periodic forcing\n amplitude = np.sin(force_freq*2*np.pi*t)**21\n force = amplitude*force_kernel\n state += force_amount*force\n\n # Random time-varying Gaussian colored noise\n noise = (1-noise_inertia)*npr.randn(*noise.shape) + noise_inertia*noise\n state += noise_amount*noise\n\n return state, noise", "_____no_output_____" ] ], [ [ "## Plotting", "_____no_output_____" ] ], [ [ "# Initialize the plot\nplt.ioff()\nfig, ax = plt.subplots()\nim = plt.imshow(state, vmin=0, vmax=1)\nax.axis('off')\nfig.tight_layout()\n\n\ndef update(t):\n global state, noise\n state, noise = physics_update(state, noise, t)\n im.set_data(state)\n return [im]\n\n\n# Create the animation\nanimation = FuncAnimation(fig, update, frames=duration, interval=20, blit=True)\nHTML(animation.to_html5_video()) # simple video\n# HTML(animation.to_jshtml()) # interactive video player", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import csv\nimport os\nimport glob\nimport re\nfrom pandas import DataFrame, Series\nfrom PIL import Image\nimport timeit\nimport time", "_____no_output_____" ], [ "## CHANGE THESE TO POINT TO VALID AND TRAIN FOR ALL CATEGORIES\n## PRESERVE THE ORDER\ntrain_paths = [\"/scratch/kk4ze/data_lowres_1100x1100_augmented/valid/Celiac\", \"/scratch/kk4ze/data_lowres_1100x1100_augmented/valid/EE\", \n \"/scratch/kk4ze/data_lowres_1100x1100_augmented/valid/Normal\", \"/scratch/kk4ze/data_lowres_1100x1100_augmented/train/Celiac\", \n \"/scratch/kk4ze/data_lowres_1100x1100_augmented/train/EE\", \"/scratch/kk4ze/data_lowres_1100x1100_augmented/train/Normal\"]\n\nimages = {}\nimages_by_folder = {}\nfor train_path in train_paths:\n images_by_folder[str(train_path)] = []\n files = glob.glob(os.path.join(train_path, '*.jpg'))\n for fl in files:\n flbase = os.path.basename(fl)\n flbase_noext = os.path.splitext(flbase)[0]\n images[flbase_noext]=fl\n images_by_folder[str(train_path)].append(flbase_noext)", "_____no_output_____" ], [ "from shutil import copyfile\n\n# CHANGE THESE PATHS TO POINT TO TRAIN AND VALID FOLDER FOR Normal RESPECTIVELY \ntrain_paths = [\"/scratch/kk4ze/data_lowres_1100x1100_augmented/train/Normal\"]\nvalid_paths = [\"/scratch/kk4ze/data_lowres_1100x1100_augmented/valid/Normal\"]\n\n## CHANGE THESE TO POINT TO TRAIN AND VALID FOLDER WITH THE MAXIMUM NUMBER OF FILES IN BOTH\n## EXAMPLE CHANGE max_train PATH TO POINT TO train/EE or train/Celiac or train/Normal. WHICHEVER HAS MAXIMUM NUMBER OF FILES\n## SIMILARLY FOR max_valid. BOTH COULD POINT TO DIFFERENT CATEGORIES!\n### MAKE SURE THESE ARE THE SAME IN ALL THREE SCRIPTS\nmax_train = len(images_by_folder[\"/scratch/kk4ze/data_lowres_1100x1100_augmented/train/Celiac\"])\nmax_valid = len(images_by_folder[\"/scratch/kk4ze/data_lowres_1100x1100_augmented/valid/Celiac\"])\n\nfor path in train_paths:\n mult = int(round(max_train / len(images_by_folder[str(path)])))\n print (str(path) + \" Multiply index: \" + str(mult) + \" Original SIze: \" + str(len(images_by_folder[str(path)])))\n counter = 0\n for img in images_by_folder[str(path)]:\n counter = counter + 1\n if (counter % 10000 == 0):\n print(counter)\n src = str(path) + \"/\" + str(img) + '.jpg'\n# dst = '../data_segments/' + 'data_balanced_duplicate_sample/' + str(path.split('/')[-2].strip()) + '/' + str(path.split('/')[-1].strip()) + '/' + str(img)\n for i in range(mult):\n dst = '/scratch/kk4ze/' + 'data_lowres_1100x1100_augmented_duplicated/' + str(path.split('/')[-2].strip()) + '/' + str(path.split('/')[-1].strip()) + '/' + str(img) + '_' + str(i) + '.jpg'\n copyfile(src, dst)\n \nprint ('Doing Valid now!')\nfor path in valid_paths:\n mult = int(round(max_valid / len(images_by_folder[str(path)])))\n print (str(path) + \" Multiply index: \" + str(mult) + \" Original Size: \" + str(len(images_by_folder[str(path)])))\n counter = 0\n for img in images_by_folder[str(path)]:\n counter = counter + 1\n if (counter % 10000 == 0):\n print(counter)\n src = str(path) + \"/\" + str(img) + '.jpg'\n# dst = '../data_segments/' + 'data_balanced_duplicate_sample/' + str(path.split('/')[-2].strip()) + '/' + str(path.split('/')[-1].strip()) + '/' + str(img) \n for i in range(mult):\n dst = '/scratch/kk4ze/' + 'data_lowres_1100x1100_augmented_duplicated/' + str(path.split('/')[-2].strip()) + '/' + str(path.split('/')[-1].strip()) + '/' + str(img) + '_' + str(i) + '.jpg'\n copyfile(src, dst)", "/scratch/kk4ze/data_lowres_1100x1100_augmented/train/Normal Multiply index: 1 Original SIze: 283\nDoing Valid now!\n/scratch/kk4ze/data_lowres_1100x1100_augmented/valid/Normal Multiply index: 1 Original Size: 76\n" ] ] ]

[ "code" ]

[ [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# waimai_10k 说明\n0. **下载地址：** [Github](https://github.com/SophonPlus/ChineseNlpCorpus/raw/master/datasets/waimai_10k/waimai_10k.csv)\n1. **数据概览：** 某外卖平台收集的用户评价，正向 4000 条，负向 约 8000 条\n2. **推荐实验：** 情感/观点/评论 倾向性分析\n2. **数据来源：** 某外卖平台\n3. **原数据集：** [中文短文本情感分析语料 外卖评价](https://download.csdn.net/download/cstkl/10236683)，网上搜集，具体作者、来源不详\n4. **加工处理：**\n 1. 将原来 2 个文件整合到 1 个文件中\n 2. 去重", "_____no_output_____" ] ], [ [ "import pandas as pd", "_____no_output_____" ], [ "path = 'waimai_10k_文件夹_所在_路径'", "_____no_output_____" ] ], [ [ "# 1. waimai_10k.csv", "_____no_output_____" ], [ "## 加载数据", "_____no_output_____" ] ], [ [ "pd_all = pd.read_csv(path + 'waimai_10k.csv')\n\nprint('评论数目（总体）：%d' % pd_all.shape[0])\nprint('评论数目（正向）：%d' % pd_all[pd_all.label==1].shape[0])\nprint('评论数目（负向）：%d' % pd_all[pd_all.label==0].shape[0])", "评论数目（总体）：11987\n评论数目（正向）：4000\n评论数目（负向）：7987\n" ] ], [ [ "## 字段说明\n\n| 字段 | 说明 |\n| ---- | ---- |\n| label | 1 表示正向评论，0 表示负向评论 |\n| review | 评论内容 |", "_____no_output_____" ] ], [ [ "pd_all.sample(20)", "_____no_output_____" ] ], [ [ "# 2. 构造平衡语料", "_____no_output_____" ] ], [ [ "pd_positive = pd_all[pd_all.label==1]\npd_negative = pd_all[pd_all.label==0]\n\ndef get_balance_corpus(corpus_size, corpus_pos, corpus_neg):\n sample_size = corpus_size // 2\n pd_corpus_balance = pd.concat([corpus_pos.sample(sample_size, replace=corpus_pos.shape[0]<sample_size), \\\n corpus_neg.sample(sample_size, replace=corpus_neg.shape[0]<sample_size)])\n \n print('评论数目（总体）：%d' % pd_corpus_balance.shape[0])\n print('评论数目（正向）：%d' % pd_corpus_balance[pd_corpus_balance.label==1].shape[0])\n print('评论数目（负向）：%d' % pd_corpus_balance[pd_corpus_balance.label==0].shape[0]) \n \n return pd_corpus_balance", "_____no_output_____" ], [ "waimai_10k_ba_4000 = get_balance_corpus(4000, pd_positive, pd_negative)\n\nwaimai_10k_ba_4000.sample(10)", "评论数目（总体）：4000\n评论数目（正向）：2000\n评论数目（负向）：2000\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# # Data augmentation using python and keras\n\nfrom keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array\nfrom keras.preprocessing.image import load_img\n\ndatagen = ImageDataGenerator(\n rotation_range = 40,\n width_shift_range=0.2,\n height_shift_range=0.2,\n shear_range=0.2,\n zoom_range=0.2,\n horizontal_flip=True,\n fill_mode='nearest')\nimg = load_img('tales_4.png')\nimage_to_array_conversion = img_to_array(img)\nimage_to_array_conversion = image_to_array_conversion.reshape((1,)+image_to_array_conversion.shape)\n# the .flow() command generates batches of randomly transformed images and saves the results to 'preview' directory\ni = 0\nfor batch in datagen.flow(image_to_array_conversion, batch_size=1,\n save_to_dir='tales', save_prefix='tale', save_format='jpeg'):\n i = i + 1\n if i >100:\n break\n", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "#hide\nfrom tcdeeptools.core import *", "_____no_output_____" ] ], [ [ "# Tcdeeptools\n\n> Simple tools for deep learning development in Jupyter environments.", "_____no_output_____" ] ] ]

[ "code", "markdown" ]

[ [ "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "**Exercice sur les populations municipales et totales par département**", "_____no_output_____" ], [ "À partir des datasets population_communes.csv et surface_departements.csv, créer un nouveau dataset qui contient une ligne par département, avec ces colonnes:\\\n- la somme des \"Population municipale\" du département\\\n- la somme des \"Population totale\" du département (pour l'explication de la distinction entre \"Population municipale\" et \"Population totale\", voir: https://www.insee.fr/fr/metadonnees/definition/c1270)\\\n- la part (en pourcentage) de la population municipale par rapport à la population totale\\\n- la part (en pourcentage) de la population (municipale) du département au sein de sa région\\\n- la densité de la population (municipale) en nb d'habitants / km2\\\n(Le dataset final devrait ressembler à result-exo-cc.csv)", "_____no_output_____" ], [ "**import and some data on the data sets**", "_____no_output_____" ] ], [ [ "import pandas as pd", "_____no_output_____" ], [ "communes = pd.read_csv('population_communes.csv')\nsurfaces = pd.read_csv('surface_departements.csv')", "_____no_output_____" ], [ "communes.head(5).reset_index()", "_____no_output_____" ], [ "communes.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 70764 entries, 0 to 70763\nData columns (total 9 columns):\nCode département 70764 non-null object\nCode canton 70724 non-null float64\nCode arrondissement 70764 non-null int64\nCode région 70764 non-null int64\nNom de la commune 70764 non-null object\nCode commune 70764 non-null int64\nNom de la région 70764 non-null object\nvariable 70764 non-null object\nvalue 70764 non-null int64\ndtypes: float64(1), int64(4), object(4)\nmemory usage: 4.9+ MB\n" ] ], [ [ "**Somme des variables \"Population municipale\" du département**", "_____no_output_____" ] ], [ [ "municipale = communes[communes['variable'] == 'Population municipale']", "_____no_output_____" ], [ "municipale = municipale.groupby(['Code région', 'Code département', 'variable']).sum().reset_index()\nmunicipale = municipale.rename(columns = {'value':'Population municipale', 'Code département': 'Département'})\nmunicipale[['Code région', 'Département', 'Population municipale']]", "_____no_output_____" ] ], [ [ " ", "_____no_output_____" ], [ "**Somme des variables \"Population totale\" du département**", "_____no_output_____" ] ], [ [ "totale = communes[communes.variable == 'Population totale']\ntotale.head(3)", "_____no_output_____" ], [ "totale = totale.groupby(['Code région', 'Code département', 'variable']).sum().reset_index()\ntotale = totale.rename(columns = {'value':'Population totale', 'Code département': 'Département'})\ntotale[['Code région', 'Département', 'Population totale']]", "_____no_output_____" ] ], [ [ " ", "_____no_output_____" ], [ "**Part (en pourcentage) de la population municipale par rapport à la population totale**", "_____no_output_____" ] ], [ [ "municipale['pourcentage municipale / totale']=100 * municipale['Population municipale'] / totale['Population totale']\nmunicipale[['Code région', 'Département', 'pourcentage municipale / totale']]", "_____no_output_____" ] ], [ [ " ", "_____no_output_____" ], [ "**Part (en pourcentage) de la population (municipale) du département au sein de sa région**", "_____no_output_____" ] ], [ [ "population_région = municipale.groupby('Code région').transform('sum')['Population municipale']", "_____no_output_____" ], [ "municipale['% pop. municipale / région'] = 100*municipale['Population municipale'] / population_région\nmunicipale[['Code région', 'Département', '% pop. municipale / région']]", "_____no_output_____" ] ], [ [ " ", "_____no_output_____" ], [ "**Densité de la population (municipale) en nb d'habitants / km2**", "_____no_output_____" ] ], [ [ "surfaces.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 101 entries, 0 to 100\nData columns (total 3 columns):\ncode_insee 101 non-null object\nnom 101 non-null object\nsurf_km2 101 non-null float64\ndtypes: float64(1), object(2)\nmemory usage: 2.4+ KB\n" ], [ "surfaces", "_____no_output_____" ], [ "surfaces = surfaces.rename(columns = {'code_insee' : 'Département'})\nsurfaces.head(5)", "_____no_output_____" ], [ "df = municipale.merge(surfaces, left_on='Département', right_on = 'Département')\ndf", "_____no_output_____" ], [ "df['densité'] = df['Population municipale'] / df['surf_km2']\ndf[['Code région', 'Département', 'densité']]", "_____no_output_____" ], [ "dfres = pd.read_csv('result-exo-cc.csv')", "_____no_output_____" ], [ "dfres", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Text Analysis\n\n## Introduction\n\nEvery now and then you may want to analyze text that you have mined or even written yourself. For example, you may want to see (out of curiousity) what word occurs the most in a body of text.\n\nIn this notebook, we are going to analyze a well-cited astrochemistry article, titled \"Rotational Excitation of CO by Collisions with He, H, and H$_2$ Under Conditions in Interstellar Clouds\" by Green and Thaddeus, published in _The Astrophysical Journal_ in 1976.\n\nNormally you would have to mine the text out of a PDF - I've already done this step for you (albeit poorly). The data is located in the `data` directory.\n\nTo make sure the comparison is consistent throughout the analysis, we have to make sure we remove as much of the special characters and lower/upper casing as possible.\n\n## Aim\n\nThe objective in this notebook is to open the text file in Python, parse out every word, and generate a histogram of word occurances. The scope will be to pick up all of the words __longer than 5 characters__, and count the number of times they appear.\n\n__Note that your partner will have to perform the same analysis on a different text! Make sure your code is clean and well documented!__\n\nThese are the steps you need to take:\n\n1. Open the text file for reading\n2. Remove special characters from the text and remove case-sensitivity\n - I recommend replacing special characters with spaces!\n3. Loop through the words, and incrementing each time you find the same word again.\n4. Histogram count the words\n - This can be done with the `Counter` function from `collections`, or with `pandas DataFrame` built-in methods.\n5. Plot up the histogram with `matplotlib`\n\nThis is the preamble you probably need:", "_____no_output_____" ] ], [ [ "%matplotlib inline\n# This function will count the occurances in a list\nfrom collections import Counter\n\n# For your histogram needs\nimport numpy as np\n\n# Optional, if you're courageous!\nimport pandas as pd\n\n# For the plotting\nfrom matplotlib import pyplot as plt", "_____no_output_____" ] ], [ [ "## Method\n\n1. Open a text file and read in its contents in a \"Pythonic\" way.", "_____no_output_____" ] ], [ [ "with open(\"data/GreenThaddeus-1976-ApJ.txt\") as read_file:\n lines = read_file.read()", "_____no_output_____" ] ], [ [ "2. Clean up the text so that it's more easily processed, i.e. removing newline characters and other special characters", "_____no_output_____" ] ], [ [ "for character in [\"\\n\", \",\", \".\", \"\"\"(\"\"\", \"\"\")\"\"\", \"\"\":\"\"\", \"\"\"*\"\"\"]:\n lines = lines.replace(character, \" \")", "_____no_output_____" ] ], [ [ "3. I chose to store the data in a Python dictionary, where the key corresponds to the word, and the value is the count.", "_____no_output_____" ] ], [ [ "word_dict = dict()", "_____no_output_____" ], [ "for word in lines.split(\" \"):\n # If there are more than 5 characters, and is not a number then we count\n if len(word) > 5 and word.isdigit() is False:\n # If the word is not already in the dictionary, add it in\n if word.lower() not in word_dict:\n word_dict[word.lower()] = 1\n # Otherwise just increment the counter\n else:\n word_dict[word.lower()]+=1", "_____no_output_____" ] ], [ [ "4. The way I chose to analyze the data was to use `pandas`. You can easily convert the dictionary into a `pandas` `DataFrame`, which handles in a SQL-like fashion. I've oriented the `DataFrame` such that the words are in the index, and column 0 is the occurance.", "_____no_output_____" ] ], [ [ "df = pd.DataFrame.from_dict(word_dict, orient=\"index\")", "_____no_output_____" ] ], [ [ "5. The values are sorted in descending order, and in place (so nothing is returned from the function call)", "_____no_output_____" ] ], [ [ "df.sort_values([0], ascending=False, inplace=True)", "_____no_output_____" ] ], [ [ "6. Since I didn't want to swamp the figure, I am plotting only the top 10 occurances of a word. The `iloc` method will let you slice/select indices of a dataframe. I code below simply chooses the first 10 values of a dataframe.", "_____no_output_____" ] ], [ [ "cut_df = df.iloc[:10]", "_____no_output_____" ], [ "plt.style.use(\"seaborn\")\n\nfig, ax = plt.subplots(figsize=(10,6))\n\nax.bar(cut_df.index, cut_df[0])\n\nax.set_title(\"Top 10 words in Green & Thaddeus, 1976\")", "_____no_output_____" ], [ "fig.savefig(\"figures/Green1976-top10.png\", dpi=300)", "_____no_output_____" ] ], [ [ "## Partner objective\n\nSend your partner your notebook and the other text file (data/Schlegel-arxiv.txt). Tell them to run your notebook, and then ask them to perform the same analysis with the __top 5 words with 4 or more characters!__", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import h5py", "_____no_output_____" ], [ "f = h5py.File('./spatial/gqa_spatial_15.h5', 'r')", "_____no_output_____" ], [ "list(f.keys())", "_____no_output_____" ], [ "dset = f['features']", "_____no_output_____" ], [ "dset.shape", "_____no_output_____" ], [ "dset[581]", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "\n<a href=\"https://colab.research.google.com/github/luanps/albert/blob/master/albert_finetune_optimization.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "# @title Copyright 2020 The ALBERT Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================", "_____no_output_____" ] ], [ [ "# ALBERT End to End (Fine-tuning + Predicting) with Cloud TPU", "_____no_output_____" ], [ "## Overview\n\nALBERT is \"A Lite\" version of BERT, a popular unsupervised language representation learning algorithm. ALBERT uses parameter-reduction techniques that allow for large-scale configurations, overcome previous memory limitations, and achieve better behavior with respect to model degradation.\n\nFor a technical description of the algorithm, see our paper:\n\nhttps://arxiv.org/abs/1909.11942\n\nZhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut\n\nThis Colab demonstates using a free Colab Cloud TPU to fine-tune GLUE tasks built on top of pretrained ALBERT models and \nrun predictions on tuned model. The colab demonsrates loading pretrained ALBERT models from both [TF Hub](https://www.tensorflow.org/hub) and checkpoints.\n\n**Note:** You will need a GCP (Google Compute Engine) account and a GCS (Google Cloud \nStorage) bucket for this Colab to run.\n\nPlease follow the [Google Cloud TPU quickstart](https://cloud.google.com/tpu/docs/quickstart) for how to create GCP account and GCS bucket. You have [$300 free credit](https://cloud.google.com/free/) to get started with any GCP product. You can learn more about Cloud TPU at https://cloud.google.com/tpu/docs.\n\nThis notebook is hosted on GitHub. To view it in its original repository, after opening the notebook, select **File > View on GitHub**.", "_____no_output_____" ], [ "### Instructions", "_____no_output_____" ], [ "<h3><a href=\"https://cloud.google.com/tpu/\"><img valign=\"middle\" src=\"https://raw.githubusercontent.com/GoogleCloudPlatform/tensorflow-without-a-phd/master/tensorflow-rl-pong/images/tpu-hexagon.png\" width=\"50\"></a> &nbsp;&nbsp;Train on TPU</h3>\n\n 1. Create a Cloud Storage bucket for your TensorBoard logs at http://console.cloud.google.com/storage and fill in the BUCKET parameter in the \"Parameters\" section below.\n \n 1. On the main menu, click Runtime and select **Change runtime type**. Set \"TPU\" as the hardware accelerator.\n 1. Click Runtime again and select **Runtime > Run All** (Watch out: the \"Colab-only auth for this notebook and the TPU\" cell requires user input). You can also run the cells manually with Shift-ENTER.", "_____no_output_____" ], [ "### Set up your TPU environment\n\nIn this section, you perform the following tasks:\n\n* Set up a Colab TPU running environment\n* Verify that you are connected to a TPU device\n* Upload your credentials to TPU to access your GCS bucket.", "_____no_output_____" ] ], [ [ "# TODO(lanzhzh): Add support for 2.x.\n%tensorflow_version 1.x\nimport os\nimport pprint\nimport json\nimport tensorflow as tf\n\nassert \"COLAB_TPU_ADDR\" in os.environ, \"ERROR: Not connected to a TPU runtime; please see the first cell in this notebook for instructions!\"\nTPU_ADDRESS = \"grpc://\" + os.environ[\"COLAB_TPU_ADDR\"] \nTPU_TOPOLOGY = \"2x2\"\nprint(\"TPU address is\", TPU_ADDRESS)\n\nfrom google.colab import auth\nauth.authenticate_user()\nwith tf.Session(TPU_ADDRESS) as session:\n print('TPU devices:')\n pprint.pprint(session.list_devices())\n\n # Upload credentials to TPU.\n with open('/content/adc.json', 'r') as f:\n auth_info = json.load(f)\n tf.contrib.cloud.configure_gcs(session, credentials=auth_info)\n # Now credentials are set for all future sessions on this TPU.", "TensorFlow 1.x selected.\nTPU address is grpc://10.109.125.66:8470\nWARNING:tensorflow:\nThe TensorFlow contrib module will not be included in TensorFlow 2.0.\nFor more information, please see:\n * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n * https://github.com/tensorflow/addons\n * https://github.com/tensorflow/io (for I/O related ops)\nIf you depend on functionality not listed there, please file an issue.\n\nTPU devices:\n[_DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:CPU:0, CPU, -1, 2409099261969407911),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 17179869184, 1549954337002144741),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:0, TPU, 17179869184, 5510839357321454835),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:1, TPU, 17179869184, 873393571816079649),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:2, TPU, 17179869184, 9117514880373904260),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:3, TPU, 17179869184, 12704941682957268373),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:4, TPU, 17179869184, 10623130967391006998),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:5, TPU, 17179869184, 17893873024629234993),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:6, TPU, 17179869184, 9214549767924212172),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU:7, TPU, 17179869184, 6427061617775819593),\n _DeviceAttributes(/job:tpu_worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 8589934592, 2138631231408532535)]\n" ] ], [ [ "### Prepare and import ALBERT modules\n​\nWith your environment configured, you can now prepare and import the ALBERT modules. The following step clones the source code from GitHub.", "_____no_output_____" ] ], [ [ "import sys\n\n!test -d albert || git clone https://github.com/google-research/albert albert\nif not 'albert' in sys.path:\n sys.path += ['albert']\n \n!pip install sentencepiece\n", "Cloning into 'albert'...\nremote: Enumerating objects: 367, done.\u001b[K\nremote: Counting objects: 100% (14/14), done.\u001b[K\nremote: Compressing objects: 100% (11/11), done.\u001b[K\nremote: Total 367 (delta 5), reused 6 (delta 3), pack-reused 353\u001b[K\nReceiving objects: 100% (367/367), 262.46 KiB | 3.50 MiB/s, done.\nResolving deltas: 100% (237/237), done.\nCollecting sentencepiece\n Downloading sentencepiece-0.1.96-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.2 MB)\n\u001b[K |████████████████████████████████| 1.2 MB 5.2 MB/s \n\u001b[?25hInstalling collected packages: sentencepiece\nSuccessfully installed sentencepiece-0.1.96\n" ] ], [ [ "## Prepare for training\n\nThis next section of code performs the following tasks:\n\n* Specify GS bucket, create output directory for model checkpoints and eval results.\n* Specify task and download training data.\n* Specify ALBERT pretrained model\n\n\n\n", "_____no_output_____" ] ], [ [ "#Download GLUE data\n!git clone https://github.com/nyu-mll/GLUE-baselines download_glue\n\nGLUE_DIR='glue_data'\n!python download_glue/download_glue_data.py --data_dir $GLUE_DIR --tasks all", "_____no_output_____" ], [ "# Please find the full list of tasks and their fintuning hyperparameters\n# here https://github.com/google-research/albert/blob/master/run_glue.sh\n\nBUCKET = \"luanps\" #@param { type: \"string\" }\nTASK = 'RTE' #@param {type:\"string\"}\n# Available pretrained model checkpoints:\n# base, large, xlarge, xxlarge\nALBERT_MODEL = 'base' #@param {type:\"string\"}\n\nTASK_DATA_DIR = 'glue_data'\n\nBASE_DIR = \"gs://\" + BUCKET\nif not BASE_DIR or BASE_DIR == \"gs://\":\n raise ValueError(\"You must enter a BUCKET.\")\nDATA_DIR = os.path.join(BASE_DIR, \"data\")\nMODELS_DIR = os.path.join(BASE_DIR, \"models\")\nOUTPUT_DIR = 'gs://{}/albert-tfhub/models/{}'.format(BUCKET, TASK)\ntf.gfile.MakeDirs(OUTPUT_DIR)\nprint('***** Model output directory: {} *****'.format(OUTPUT_DIR))\n\n# Download glue data.\n#! test -d download_glue_repo || git clone https://gist.github.com/60c2bdb54d156a41194446737ce03e2e.git download_glue_repo\n#!python download_glue_repo/download_glue_data.py --data_dir=$TASK_DATA_DIR --tasks=$TASK\n#print('***** Task data directory: {} *****'.format(TASK_DATA_DIR))\n\nALBERT_MODEL_HUB = 'https://tfhub.dev/google/albert_' + ALBERT_MODEL + '/3'", "***** Model output directory: gs://luanps/albert-tfhub/models/RTE *****\n" ] ], [ [ "Now let's run the fine-tuning scripts. If you use the default MRPC task, this should be finished in around 10 mintues and you will get an accuracy of around 86.5.", "_____no_output_____" ], [ "## Choose hyperparameters using [Optuna](https://optuna.readthedocs.io/en/stable/index.html)", "_____no_output_____" ] ], [ [ "#Install Optuna optimzation lib\n!pip install optuna", "_____no_output_____" ], [ "import optuna\nimport uuid", "_____no_output_____" ], [ "def get_last_acc_from_file(result_file):\n f = open(result_file,'r')\n results = f.readlines()\n result_dict = dict()\n for r in results:\n if 'eval_accuracy' in r:\n k,v = r.split(' = ')\n return float(v)", "_____no_output_____" ], [ "def objective(trial):\n\n #hyperparameter setting: RTE task\n warmup_steps = trial.suggest_int('warmup_steps', 100, 500,100)\n train_steps = trial.suggest_int('train_steps', 400, 2000,100)\n learning_rate = trial.suggest_loguniform(\"learning_rate\", 1e-5, 5e-5)\n batch_size = trial.suggest_int('batch_size', 16, 128,16)\n\n #Tmp config\n id = str(uuid.uuid4()).split('-')[0]\n OUTPUT_TMP = f'{OUTPUT_DIR}/{id}'\n os.environ['TFHUB_CACHE_DIR'] = OUTPUT_TMP\n\n !python -m albert.run_classifier \\\n --data_dir=\"glue_data/\" \\\n --output_dir=$OUTPUT_TMP \\\n --albert_hub_module_handle=$ALBERT_MODEL_HUB \\\n --spm_model_file=\"from_tf_hub\" \\\n --do_train=True \\\n --do_eval=True \\\n --do_predict=False \\\n --max_seq_length=512 \\\n --optimizer=adamw \\\n --task_name=$TASK \\\n --warmup_step=$warmup_steps \\\n --learning_rate=$learning_rate \\\n --train_step=$train_steps \\\n --save_checkpoints_steps=100 \\\n --train_batch_size=$batch_size\\\n --tpu_name=$TPU_ADDRESS \\\n --use_tpu=True\n\n #Download results and load model accuracy\n !mkdir $id\n !gsutil cp $OUTPUT_TMP/eval_results.txt $id\n model_acc = get_last_acc_from_file(f'{id}/eval_results.txt')\n return model_acc", "_____no_output_____" ], [ "#Run Optuna optimization\nstudy = optuna.create_study(direction='maximize',study_name=TASK)\nstudy.optimize(objective, n_trials=20)", "_____no_output_____" ], [ "#Pack Optuna results and save to Bucket\nimport joblib\n\nstudy_file = f'{TASK}_study.pkl'\n!rm $study_file\njoblib.dump(study, study_file)\n!gsutil cp $study_file $OUTPUT_DIR", "Copying file://RTE_study.pkl [Content-Type=application/octet-stream]...\n/ [1 files][ 13.6 KiB/ 13.6 KiB] \nOperation completed over 1 objects/13.6 KiB. \n" ], [ "study.trials_dataframe()", "_____no_output_____" ] ], [ [ "## Analyzing Optimization Results", "_____no_output_____" ] ], [ [ "#Download pkl file from GCP\nimport joblib\n\nstudy_file = f'{TASK}_study.pkl'\n!gsutil cp $OUTPUT_DIR/$study_file .\n\nstudy = joblib.load(study_file)\n", "Copying gs://luanps/albert-tfhub/models/RTE/RTE_study.pkl...\n/ [1 files][ 7.8 KiB/ 7.8 KiB] \nOperation completed over 1 objects/7.8 KiB. \n" ], [ "study.trials_dataframe()", "_____no_output_____" ], [ "import optuna\nfrom optuna.visualization import plot_contour\nfrom optuna.visualization import plot_edf\nfrom optuna.visualization import plot_intermediate_values\nfrom optuna.visualization import plot_optimization_history\nfrom optuna.visualization import plot_parallel_coordinate\nfrom optuna.visualization import plot_param_importances\nfrom optuna.visualization import plot_slice\n", "_____no_output_____" ], [ "plot_optimization_history(study)", "_____no_output_____" ], [ "plot_parallel_coordinate(study)", "_____no_output_____" ], [ "plot_contour(study)", "_____no_output_____" ], [ "plot_slice(study)", "_____no_output_____" ], [ "plot_param_importances(study)", "_____no_output_____" ], [ "plot_edf(study)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import sys, os\nif 'google.colab' in sys.modules and not os.path.exists('.setup_complete'):\n !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/spring20/setup_colab.sh -O- | bash\n\n !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/coursera/grading.py -O ../grading.py\n !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/coursera/week6_outro/submit.py\n\n !touch .setup_complete\n\n# This code creates a virtual display to draw game images on.\n# It will have no effect if your machine has a monitor.\nif type(os.environ.get(\"DISPLAY\")) is not str or len(os.environ.get(\"DISPLAY\")) == 0:\n !bash ../xvfb start\n os.environ['DISPLAY'] = ':1'", "_____no_output_____" ], [ "from abc import ABCMeta, abstractmethod, abstractproperty\nimport enum\n\nimport numpy as np\nnp.set_printoptions(precision=3)\nnp.set_printoptions(suppress=True)\n\nimport pandas\n\nfrom matplotlib import pyplot as plt\n%matplotlib inline", "_____no_output_____" ] ], [ [ "## Bernoulli Bandit\n\nWe are going to implement several exploration strategies for simplest problem - bernoulli bandit.\n\nThe bandit has $K$ actions. Action produce 1.0 reward $r$ with probability $0 \\le \\theta_k \\le 1$ which is unknown to agent, but fixed over time. Agent's objective is to minimize regret over fixed number $T$ of action selections:\n\n$$\\rho = T\\theta^* - \\sum_{t=1}^T r_t$$\n\nWhere $\\theta^* = \\max_k\\{\\theta_k\\}$\n\n**Real-world analogy:**\n\nClinical trials - we have $K$ pills and $T$ ill patient. After taking pill, patient is cured with probability $\\theta_k$. Task is to find most efficient pill.\n\nA research on clinical trials - https://arxiv.org/pdf/1507.08025.pdf", "_____no_output_____" ] ], [ [ "class BernoulliBandit:\n def __init__(self, n_actions=5):\n self._probs = np.random.random(n_actions)\n\n @property\n def action_count(self):\n return len(self._probs)\n\n def pull(self, action):\n if np.any(np.random.random() > self._probs[action]):\n return 0.0\n return 1.0\n\n def optimal_reward(self):\n \"\"\" Used for regret calculation\n \"\"\"\n return np.max(self._probs)\n\n def step(self):\n \"\"\" Used in nonstationary version\n \"\"\"\n pass\n\n def reset(self):\n \"\"\" Used in nonstationary version\n \"\"\"", "_____no_output_____" ], [ "class AbstractAgent(metaclass=ABCMeta):\n def init_actions(self, n_actions):\n self._successes = np.zeros(n_actions)\n self._failures = np.zeros(n_actions)\n self._total_pulls = 0\n\n @abstractmethod\n def get_action(self):\n \"\"\"\n Get current best action\n :rtype: int\n \"\"\"\n pass\n\n def update(self, action, reward):\n \"\"\"\n Observe reward from action and update agent's internal parameters\n :type action: int\n :type reward: int\n \"\"\"\n self._total_pulls += 1\n if reward == 1:\n self._successes[action] += 1\n else:\n self._failures[action] += 1\n\n @property\n def name(self):\n return self.__class__.__name__\n\n\nclass RandomAgent(AbstractAgent):\n def get_action(self):\n return np.random.randint(0, len(self._successes))", "_____no_output_____" ] ], [ [ "### Epsilon-greedy agent\n\n**for** $t = 1,2,...$ **do**\n\n&nbsp;&nbsp; **for** $k = 1,...,K$ **do**\n\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $\\hat\\theta_k \\leftarrow \\alpha_k / (\\alpha_k + \\beta_k)$\n\n&nbsp;&nbsp; **end for** \n\n&nbsp;&nbsp; $x_t \\leftarrow argmax_{k}\\hat\\theta$ with probability $1 - \\epsilon$ or random action with probability $\\epsilon$\n\n&nbsp;&nbsp; Apply $x_t$ and observe $r_t$\n\n&nbsp;&nbsp; $(\\alpha_{x_t}, \\beta_{x_t}) \\leftarrow (\\alpha_{x_t}, \\beta_{x_t}) + (r_t, 1-r_t)$\n\n**end for**\n\nImplement the algorithm above in the cell below:", "_____no_output_____" ] ], [ [ "class EpsilonGreedyAgent(AbstractAgent):\n def __init__(self, epsilon=0.01):\n self._epsilon = epsilon\n\n def get_action(self):\n # <YOUR CODE>\n alpha = self._successes\n beta = self._failures\n \n theta_ = alpha / (alpha + beta)\n if np.random.random() < self._epsilon:\n return np.random.randint(0, len(alpha))\n else:\n return np.argmax(theta_)\n\n @property\n def name(self):\n return self.__class__.__name__ + \"(epsilon={})\".format(self._epsilon)", "_____no_output_____" ] ], [ [ "### UCB Agent\nEpsilon-greedy strategy heve no preference for actions. It would be better to select among actions that are uncertain or have potential to be optimal. One can come up with idea of index for each action that represents otimality and uncertainty at the same time. One efficient way to do it is to use UCB1 algorithm:\n\n**for** $t = 1,2,...$ **do**\n\n&nbsp;&nbsp; **for** $k = 1,...,K$ **do**\n\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $w_k \\leftarrow \\alpha_k / (\\alpha_k + \\beta_k) + \\sqrt{2log\\ t \\ / \\ (\\alpha_k + \\beta_k)}$\n\n&nbsp;&nbsp; **end for** \n\n&nbsp;&nbsp; **end for** \n $x_t \\leftarrow argmax_{k}w$\n\n&nbsp;&nbsp; Apply $x_t$ and observe $r_t$\n\n&nbsp;&nbsp; $(\\alpha_{x_t}, \\beta_{x_t}) \\leftarrow (\\alpha_{x_t}, \\beta_{x_t}) + (r_t, 1-r_t)$\n\n**end for**\n\n__Note:__ in practice, one can multiply $\\sqrt{2log\\ t \\ / \\ (\\alpha_k + \\beta_k)}$ by some tunable parameter to regulate agent's optimism and wilingness to abandon non-promising actions.\n\nMore versions and optimality analysis - https://homes.di.unimi.it/~cesabian/Pubblicazioni/ml-02.pdf", "_____no_output_____" ] ], [ [ "class UCBAgent(AbstractAgent):\n def __init__(self, gamma=0.01):\n self._gamma = gamma\n \n def get_action(self):\n # <YOUR CODE>\n alpha = self._successes\n beta = self._failures\n t = self._total_pulls\n \n omega_ = alpha / (alpha + beta) + self._gamma * np.sqrt(2*np.log(t) / (alpha+beta))\n return np.argmax(omega_)\n \n @property\n def name(self):\n return self.__class__.__name__ + \"(gamma={})\".format(self._gamma)", "_____no_output_____" ] ], [ [ "### Thompson sampling\n\nUCB1 algorithm does not take into account actual distribution of rewards. If we know the distribution - we can do much better by using Thompson sampling:\n\n**for** $t = 1,2,...$ **do**\n\n&nbsp;&nbsp; **for** $k = 1,...,K$ **do**\n\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Sample $\\hat\\theta_k \\sim beta(\\alpha_k, \\beta_k)$\n\n&nbsp;&nbsp; **end for** \n\n&nbsp;&nbsp; $x_t \\leftarrow argmax_{k}\\hat\\theta$\n\n&nbsp;&nbsp; Apply $x_t$ and observe $r_t$\n\n&nbsp;&nbsp; $(\\alpha_{x_t}, \\beta_{x_t}) \\leftarrow (\\alpha_{x_t}, \\beta_{x_t}) + (r_t, 1-r_t)$\n\n**end for**\n \n\nMore on Thompson Sampling:\nhttps://web.stanford.edu/~bvr/pubs/TS_Tutorial.pdf", "_____no_output_____" ] ], [ [ "class ThompsonSamplingAgent(AbstractAgent):\n def get_action(self):\n # <YOUR CODE>\n alpha = self._successes\n beta = self._failures\n \n theta_ = np.random.beta(alpha+1, beta+1)\n return np.argmax(theta_)\n", "_____no_output_____" ], [ "from collections import OrderedDict\n\ndef get_regret(env, agents, n_steps=5000, n_trials=50):\n scores = OrderedDict({\n agent.name: [0.0 for step in range(n_steps)] for agent in agents\n })\n\n for trial in range(n_trials):\n env.reset()\n\n for a in agents:\n a.init_actions(env.action_count)\n\n for i in range(n_steps):\n optimal_reward = env.optimal_reward()\n\n for agent in agents:\n action = agent.get_action()\n reward = env.pull(action)\n agent.update(action, reward)\n scores[agent.name][i] += optimal_reward - reward\n\n env.step() # change bandit's state if it is unstationary\n\n for agent in agents:\n scores[agent.name] = np.cumsum(scores[agent.name]) / n_trials\n\n return scores\n\ndef plot_regret(agents, scores):\n for agent in agents:\n plt.plot(scores[agent.name])\n\n plt.legend([agent.name for agent in agents])\n\n plt.ylabel(\"regret\")\n plt.xlabel(\"steps\")\n\n plt.show()", "_____no_output_____" ], [ "# Uncomment agents\nagents = [\n EpsilonGreedyAgent(),\n UCBAgent(0.1),\n UCBAgent(0.2),\n ThompsonSamplingAgent()\n]\n\nregret = get_regret(BernoulliBandit(), agents, n_steps=10000, n_trials=10)\nplot_regret(agents, regret)", "/home/x/anaconda3/envs/rl/lib/python3.7/site-packages/ipykernel_launcher.py:10: RuntimeWarning: invalid value encountered in true_divide\n # Remove the CWD from sys.path while we load stuff.\n/home/x/anaconda3/envs/rl/lib/python3.7/site-packages/ipykernel_launcher.py:11: RuntimeWarning: invalid value encountered in true_divide\n # This is added back by InteractiveShellApp.init_path()\n/home/x/anaconda3/envs/rl/lib/python3.7/site-packages/ipykernel_launcher.py:11: RuntimeWarning: divide by zero encountered in log\n # This is added back by InteractiveShellApp.init_path()\n/home/x/anaconda3/envs/rl/lib/python3.7/site-packages/ipykernel_launcher.py:11: RuntimeWarning: invalid value encountered in sqrt\n # This is added back by InteractiveShellApp.init_path()\n/home/x/anaconda3/envs/rl/lib/python3.7/site-packages/ipykernel_launcher.py:11: RuntimeWarning: divide by zero encountered in true_divide\n # This is added back by InteractiveShellApp.init_path()\n" ] ], [ [ "### Submit to coursera", "_____no_output_____" ] ], [ [ "from submit import submit_bandits\n\nsubmit_bandits(agents, regret, '', '')", "Submitted to Coursera platform. See results on assignment page!\n" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "Realizar:\n1. Crear una lista de enteros en Python y realizar la suma con recursividad, el caso base es cuando la lista este vacía.\n2. Hacer un contador regresivo con recursión.\n3. Sacar de un ADT pila el valor en la posición media.", "_____no_output_____" ] ], [ [ "class Pila:\n def __init__(self):\n self.items = []\n \n def imprimirCompleto(self):\n for x in range(0,len(self.items),1):\n print(self.items[x],end=\",\")\n \n def estaVacia(self):\n return self.items == []\n\n def incluir(self, item):\n self.items.append(item)\n \n def extraerPrimero(self):\n return self.items.pop(0)\n \n def extraerUltimo(self):\n return self.items.pop()\n\n def inspeccionarUltimo(self):\n return self.items[len(self.items)-1]\n\n def tamano(self):\n return len(self.items)\n \ndef sumaRec(lista,longitud,suma = 0):\n if longitud != 0:\n suma += lista[longitud-1]\n print(suma)\n sumaRec(lista,longitud-1,suma)\n \ndef contador(maximo):\n if maximo != 0:\n print(maximo)\n contador(maximo-1)\n \ndef posicionRec(pila):\n lon = pila.tamano()\n if lon == 1:\n print(\"\\nEl elemento de la posicicon media es: \",pila.inspeccionarUltimo())\n else:\n pila.extraerPrimero()\n pila.extraerUltimo()\n posicionRec(pila)\n \ndef main():\n print(\"1. Crear una lista de enteros en Python y realizar \\nla suma con recursividad, el caso base es cuando \\nla lista este vacía.\")\n listNum = [1,2,3,4,5,6,7,8,9]\n print(listNum)\n sumaRec(listNum,len(listNum))\n \n print(\"2. Hacer un contador regresivo con recursión.\")\n print(\"INICIA CONTEO REGRESIVO\")\n contador(30)\n print(\"FINALIZA CONTEO REGRESIVO\")\n \n print(\"3. Sacar de un ADT pila el valor en la posición media\")\n p = Pila()\n p.incluir(1)\n p.incluir(2)\n p.incluir(3)\n p.incluir(4)\n p.incluir(5)\n p.incluir(6)\n p.incluir(7)\n p.incluir(8)\n p.incluir(9)\n p.imprimirCompleto()\n try:\n posicionRec(p)\n except:\n print(\"La lista no tiene posicion Media\")\nmain()\n\n", "1. Crear una lista de enteros en Python y realizar \nla suma con recursividad, el caso base es cuando \nla lista este vacía.\n[1, 2, 3, 4, 5, 6, 7, 8, 9]\n9\n17\n24\n30\n35\n39\n42\n44\n45\n2. Hacer un contador regresivo con recursión.\nINICIA CONTEO REGRESIVO\n30\n29\n28\n27\n26\n25\n24\n23\n22\n21\n20\n19\n18\n17\n16\n15\n14\n13\n12\n11\n10\n9\n8\n7\n6\n5\n4\n3\n2\n1\nFINALIZA CONTEO REGRESIVO\n3. Sacar de un ADT pila el valor en la posición media\n1,2,3,4,5,6,7,8,9,\nEl elemento de la posicicon media es: 5\n" ] ] ]

[ "markdown", "code" ]

[ [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "Copyright (c) Microsoft Corporation. All rights reserved. \nLicensed under the MIT License.", "_____no_output_____" ], [ "", "_____no_output_____" ], [ "# Azure Machine Learning Pipelines: Getting Started\n\n## Overview\n\n\nA common scenario when using machine learning components is to have a data workflow that includes the following steps:\n\n- Preparing/preprocessing a given dataset for training, followed by\n- Training a machine learning model on this data, and then\n- Deploying this trained model in a separate environment, and finally\n- Running a batch scoring task on another data set, using the trained model.\n\nAzure's Machine Learning pipelines give you a way to combine multiple steps like these into one configurable workflow, so that multiple agents/users can share and/or reuse this workflow. Machine learning pipelines thus provide a consistent, reproducible mechanism for building, evaluating, deploying, and running ML systems.\n\nTo get more information about Azure machine learning pipelines, please read our [Azure Machine Learning Pipelines](https://aka.ms/pl-concept) overview, or the [readme article](https://aka.ms/pl-readme).\n\nIn this notebook, we provide a gentle introduction to Azure machine learning pipelines. We build a pipeline that runs jobs unattended on different compute clusters; in this notebook, you'll see how to use the basic Azure ML SDK APIs for constructing this pipeline.\n ", "_____no_output_____" ], [ "## Prerequisites and Azure Machine Learning Basics\nIf you are using an Azure Machine Learning Notebook VM, you are all set. Otherwise, make sure you go through the [configuration notebook](https://aka.ms/pl-config) first if you haven't. This sets you up with a working config file that has information on your workspace, subscription id, etc. \n", "_____no_output_____" ], [ "### Azure Machine Learning Imports\n\nIn this first code cell, we import key Azure Machine Learning modules that we will use below. ", "_____no_output_____" ] ], [ [ "import os\nimport azureml.core\nfrom azureml.core import Workspace, Experiment, Datastore\nfrom azureml.widgets import RunDetails\n\n# Check core SDK version number\nprint(\"SDK version:\", azureml.core.VERSION)", "_____no_output_____" ] ], [ [ "### Pipeline-specific SDK imports\n\nHere, we import key pipeline modules, whose use will be illustrated in the examples below.", "_____no_output_____" ] ], [ [ "from azureml.pipeline.core import Pipeline\nfrom azureml.pipeline.steps import PythonScriptStep\n\nprint(\"Pipeline SDK-specific imports completed\")", "_____no_output_____" ] ], [ [ "### Initialize Workspace\n\nInitialize a [workspace](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.workspace(class%29) object from persisted configuration.", "_____no_output_____" ] ], [ [ "ws = Workspace.from_config()\nprint(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep = '\\n')\n\n# Default datastore\ndef_blob_store = ws.get_default_datastore() \n# The following call GETS the Azure Blob Store associated with your workspace.\n# Note that workspaceblobstore is **the name of this store and CANNOT BE CHANGED and must be used as is** \ndef_blob_store = Datastore(ws, \"workspaceblobstore\")\nprint(\"Blobstore's name: {}\".format(def_blob_store.name))", "_____no_output_____" ] ], [ [ "### Required data and script files for the the tutorial\nSample files required to finish this tutorial are already copied to the corresponding source_directory locations. Even though the .py provided in the samples does not have much \"ML work\" as a data scientist, you will work on this extensively as part of your work. To complete this tutorial, the contents of these files are not very important. The one-line files are for demostration purpose only.", "_____no_output_____" ], [ "### Datastore concepts\nA [Datastore](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.datastore.datastore?view=azure-ml-py) is a place where data can be stored that is then made accessible to a compute either by means of mounting or copying the data to the compute target. \n\nA Datastore can either be backed by an Azure File Storage (default) or by an Azure Blob Storage.\n\nIn this next step, we will upload the training and test set into the workspace's default storage (File storage), and another piece of data to Azure Blob Storage. When to use [Azure Blobs](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blobs-introduction), [Azure Files](https://docs.microsoft.com/en-us/azure/storage/files/storage-files-introduction), or [Azure Disks](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/managed-disks-overview) is [detailed here](https://docs.microsoft.com/en-us/azure/storage/common/storage-decide-blobs-files-disks).\n\n**Please take good note of the concept of the datastore.**", "_____no_output_____" ], [ "#### Upload data to default datastore\nDefault datastore on workspace is the Azure File storage. The workspace has a Blob storage associated with it as well. Let's upload a file to each of these storages.", "_____no_output_____" ] ], [ [ "# get_default_datastore() gets the default Azure Blob Store associated with your workspace.\n# Here we are reusing the def_blob_store object we obtained earlier\ndef_blob_store.upload_files([\"./20news.pkl\"], target_path=\"20newsgroups\", overwrite=True)\nprint(\"Upload call completed\")", "_____no_output_____" ] ], [ [ "#### (Optional) See your files using Azure Portal\nOnce you successfully uploaded the files, you can browse to them (or upload more files) using [Azure Portal](https://portal.azure.com). At the portal, make sure you have selected your subscription (click *Resource Groups* and then select the subscription). Then look for your **Machine Learning Workspace** name. It has a link to your storage. Click on the storage link. It will take you to a page where you can see [Blobs](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blobs-introduction), [Files](https://docs.microsoft.com/en-us/azure/storage/files/storage-files-introduction), [Tables](https://docs.microsoft.com/en-us/azure/storage/tables/table-storage-overview), and [Queues](https://docs.microsoft.com/en-us/azure/storage/queues/storage-queues-introduction). We have uploaded a file each to the Blob storage and to the File storage in the above step. You should be able to see both of these files in their respective locations. ", "_____no_output_____" ], [ "### Compute Targets\nA compute target specifies where to execute your program such as a remote Docker on a VM, or a cluster. A compute target needs to be addressable and accessible by you.\n\n**You need at least one compute target to send your payload to. We are planning to use Azure Machine Learning Compute exclusively for this tutorial for all steps. However in some cases you may require multiple compute targets as some steps may run in one compute target like Azure Machine Learning Compute, and some other steps in the same pipeline could run in a different compute target.**\n\n*The example belows show creating/retrieving/attaching to an Azure Machine Learning Compute instance.*", "_____no_output_____" ], [ "#### List of Compute Targets on the workspace", "_____no_output_____" ] ], [ [ "cts = ws.compute_targets\nfor ct in cts:\n print(ct)", "_____no_output_____" ] ], [ [ "#### Retrieve or create a Azure Machine Learning compute\nAzure Machine Learning Compute is a service for provisioning and managing clusters of Azure virtual machines for running machine learning workloads. Let's create a new Azure Machine Learning Compute in the current workspace, if it doesn't already exist. We will then run the training script on this compute target.\n\nIf we could not find the compute with the given name in the previous cell, then we will create a new compute here. We will create an Azure Machine Learning Compute containing **STANDARD_D2_V2 CPU VMs**. This process is broken down into the following steps:\n\n1. Create the configuration\n2. Create the Azure Machine Learning compute\n\n**This process will take about 3 minutes and is providing only sparse output in the process. Please make sure to wait until the call returns before moving to the next cell.**", "_____no_output_____" ] ], [ [ "from azureml.core.compute import ComputeTarget, AmlCompute\nfrom azureml.core.compute_target import ComputeTargetException\n\naml_compute_target = \"cpu-cluster\"\ntry:\n aml_compute = AmlCompute(ws, aml_compute_target)\n print(\"found existing compute target.\")\nexcept ComputeTargetException:\n print(\"creating new compute target\")\n \n provisioning_config = AmlCompute.provisioning_configuration(vm_size = \"STANDARD_D2_V2\",\n min_nodes = 1, \n max_nodes = 4) \n aml_compute = ComputeTarget.create(ws, aml_compute_target, provisioning_config)\n aml_compute.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n \nprint(\"Azure Machine Learning Compute attached\")\n", "_____no_output_____" ], [ "# For a more detailed view of current Azure Machine Learning Compute status, use get_status()\n# example: un-comment the following line.\n# print(aml_compute.get_status().serialize())", "_____no_output_____" ] ], [ [ "**Wait for this call to finish before proceeding (you will see the asterisk turning to a number).**\n\nNow that you have created the compute target, let's see what the workspace's compute_targets() function returns. You should now see one entry named 'amlcompute' of type AmlCompute.", "_____no_output_____" ], [ "**Now that we have completed learning the basics of Azure Machine Learning (AML), let's go ahead and start understanding the Pipeline concepts.**", "_____no_output_____" ], [ "## Creating a Step in a Pipeline\nA Step is a unit of execution. Step typically needs a target of execution (compute target), a script to execute, and may require script arguments and inputs, and can produce outputs. The step also could take a number of other parameters. Azure Machine Learning Pipelines provides the following built-in Steps:\n\n- [**PythonScriptStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.python_script_step.pythonscriptstep?view=azure-ml-py): Adds a step to run a Python script in a Pipeline.\n- [**AdlaStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.adla_step.adlastep?view=azure-ml-py): Adds a step to run U-SQL script using Azure Data Lake Analytics.\n- [**DataTransferStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.data_transfer_step.datatransferstep?view=azure-ml-py): Transfers data between Azure Blob and Data Lake accounts.\n- [**DatabricksStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.databricks_step.databricksstep?view=azure-ml-py): Adds a DataBricks notebook as a step in a Pipeline.\n- [**HyperDriveStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.hyper_drive_step.hyperdrivestep?view=azure-ml-py): Creates a Hyper Drive step for Hyper Parameter Tuning in a Pipeline.\n- [**AzureBatchStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.azurebatch_step.azurebatchstep?view=azure-ml-py): Creates a step for submitting jobs to Azure Batch\n- [**EstimatorStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.estimator_step.estimatorstep?view=azure-ml-py): Adds a step to run Estimator in a Pipeline.\n- [**MpiStep**](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-steps/azureml.pipeline.steps.mpi_step.mpistep?view=azure-ml-py): Adds a step to run a MPI job in a Pipeline.\n- [**AutoMLStep**](https://docs.microsoft.com/en-us/python/api/azureml-train-automl/azureml.train.automl.automlstep?view=azure-ml-py): Creates a AutoML step in a Pipeline.\n\nThe following code will create a PythonScriptStep to be executed in the Azure Machine Learning Compute we created above using train.py, one of the files already made available in the `source_directory`.\n\nA **PythonScriptStep** is a basic, built-in step to run a Python Script on a compute target. It takes a script name and optionally other parameters like arguments for the script, compute target, inputs and outputs. If no compute target is specified, default compute target for the workspace is used. You can also use a [**RunConfiguration**](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.runconfiguration?view=azure-ml-py) to specify requirements for the PythonScriptStep, such as conda dependencies and docker image.\n> The best practice is to use separate folders for scripts and its dependent files for each step and specify that folder as the `source_directory` for the step. This helps reduce the size of the snapshot created for the step (only the specific folder is snapshotted). Since changes in any files in the `source_directory` would trigger a re-upload of the snapshot, this helps keep the reuse of the step when there are no changes in the `source_directory` of the step.", "_____no_output_____" ] ], [ [ "# Uses default values for PythonScriptStep construct.\n\nsource_directory = './train'\nprint('Source directory for the step is {}.'.format(os.path.realpath(source_directory)))\n\n# Syntax\n# PythonScriptStep(\n# script_name, \n# name=None, \n# arguments=None, \n# compute_target=None, \n# runconfig=None, \n# inputs=None, \n# outputs=None, \n# params=None, \n# source_directory=None, \n# allow_reuse=True, \n# version=None, \n# hash_paths=None)\n# This returns a Step\nstep1 = PythonScriptStep(name=\"train_step\",\n script_name=\"train.py\", \n compute_target=aml_compute, \n source_directory=source_directory,\n allow_reuse=True)\nprint(\"Step1 created\")", "_____no_output_____" ] ], [ [ "**Note:** In the above call to PythonScriptStep(), the flag *allow_reuse* determines whether the step should reuse previous results when run with the same settings/inputs. This flag's default value is *True*; the default is set to *True* because, when inputs and parameters have not changed, we typically do not want to re-run a given pipeline step. \n\nIf *allow_reuse* is set to *False*, a new run will always be generated for this step during pipeline execution. The *allow_reuse* flag can come in handy in situations where you do *not* want to re-run a pipeline step.", "_____no_output_____" ], [ "## Running a few steps in parallel\nHere we are looking at a simple scenario where we are running a few steps (all involving PythonScriptStep) in parallel. Running nodes in **parallel** is the default behavior for steps in a pipeline.\n\nWe already have one step defined earlier. Let's define few more steps.", "_____no_output_____" ] ], [ [ "# For this step, we use a different source_directory\nsource_directory = './compare'\nprint('Source directory for the step is {}.'.format(os.path.realpath(source_directory)))\n\n# All steps use the same Azure Machine Learning compute target as well\nstep2 = PythonScriptStep(name=\"compare_step\",\n script_name=\"compare.py\", \n compute_target=aml_compute, \n source_directory=source_directory)\n\n# Use a RunConfiguration to specify some additional requirements for this step.\nfrom azureml.core.runconfig import RunConfiguration\nfrom azureml.core.conda_dependencies import CondaDependencies\nfrom azureml.core.runconfig import DEFAULT_CPU_IMAGE\n\n# create a new runconfig object\nrun_config = RunConfiguration()\n\n# enable Docker \nrun_config.environment.docker.enabled = True\n\n# set Docker base image to the default CPU-based image\nrun_config.environment.docker.base_image = DEFAULT_CPU_IMAGE\n\n# use conda_dependencies.yml to create a conda environment in the Docker image for execution\nrun_config.environment.python.user_managed_dependencies = False\n\n# specify CondaDependencies obj\nrun_config.environment.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'])\n\n# For this step, we use yet another source_directory\nsource_directory = './extract'\nprint('Source directory for the step is {}.'.format(os.path.realpath(source_directory)))\n\nstep3 = PythonScriptStep(name=\"extract_step\",\n script_name=\"extract.py\", \n compute_target=aml_compute, \n source_directory=source_directory,\n runconfig=run_config)\n\n# list of steps to run\nsteps = [step1, step2, step3]\nprint(\"Step lists created\")", "_____no_output_____" ] ], [ [ "### Build the pipeline\nOnce we have the steps (or steps collection), we can build the [pipeline](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipeline.pipeline?view=azure-ml-py). By deafult, all these steps will run in **parallel** once we submit the pipeline for run.\n\nA pipeline is created with a list of steps and a workspace. Submit a pipeline using [submit](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.experiment(class)?view=azure-ml-py#submit-config--tags-none----kwargs-). When submit is called, a [PipelineRun](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipelinerun?view=azure-ml-py) is created which in turn creates [StepRun](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.steprun?view=azure-ml-py) objects for each step in the workflow.", "_____no_output_____" ] ], [ [ "# Syntax\n# Pipeline(workspace, \n# steps, \n# description=None, \n# default_datastore_name=None, \n# default_source_directory=None, \n# resolve_closure=True, \n# _workflow_provider=None, \n# _service_endpoint=None)\n\npipeline1 = Pipeline(workspace=ws, steps=steps)\nprint (\"Pipeline is built\")", "_____no_output_____" ] ], [ [ "### Validate the pipeline\nYou have the option to [validate](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipeline.pipeline?view=azure-ml-py#validate--) the pipeline prior to submitting for run. The platform runs validation steps such as checking for circular dependencies and parameter checks etc. even if you do not explicitly call validate method.", "_____no_output_____" ] ], [ [ "pipeline1.validate()\nprint(\"Pipeline validation complete\")", "_____no_output_____" ] ], [ [ "### Submit the pipeline\n[Submitting](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.pipeline.pipeline?view=azure-ml-py#submit) the pipeline involves creating an [Experiment](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.experiment?view=azure-ml-py) object and providing the built pipeline for submission. ", "_____no_output_____" ] ], [ [ "# Submit syntax\n# submit(experiment_name, \n# pipeline_parameters=None, \n# continue_on_step_failure=False, \n# regenerate_outputs=False)\n\npipeline_run1 = Experiment(ws, 'Hello_World1').submit(pipeline1, regenerate_outputs=False)\nprint(\"Pipeline is submitted for execution\")", "_____no_output_____" ] ], [ [ "**Note:** If regenerate_outputs is set to True, a new submit will always force generation of all step outputs, and disallow data reuse for any step of this run. Once this run is complete, however, subsequent runs may reuse the results of this run.\n", "_____no_output_____" ], [ "### Examine the pipeline run\n\n#### Use RunDetails Widget\nWe are going to use the RunDetails widget to examine the run of the pipeline. You can click each row below to get more details on the step runs.", "_____no_output_____" ] ], [ [ "RunDetails(pipeline_run1).show()", "_____no_output_____" ] ], [ [ "#### Use Pipeline SDK objects\nYou can cycle through the node_run objects and examine job logs, stdout, and stderr of each of the steps.", "_____no_output_____" ] ], [ [ "step_runs = pipeline_run1.get_children()\nfor step_run in step_runs:\n status = step_run.get_status()\n print('Script:', step_run.name, 'status:', status)\n \n # Change this if you want to see details even if the Step has succeeded.\n if status == \"Failed\":\n joblog = step_run.get_job_log()\n print('job log:', joblog)", "_____no_output_____" ] ], [ [ "#### Get additonal run details\nIf you wait until the pipeline_run is finished, you may be able to get additional details on the run. **Since this is a blocking call, the following code is commented out.**", "_____no_output_____" ] ], [ [ "#pipeline_run1.wait_for_completion()\n#for step_run in pipeline_run1.get_children():\n# print(\"{}: {}\".format(step_run.name, step_run.get_metrics()))", "_____no_output_____" ] ], [ [ "## Running a few steps in sequence\nNow let's see how we run a few steps in sequence. We already have three steps defined earlier. Let's *reuse* those steps for this part.\n\nWe will reuse step1, step2, step3, but build the pipeline in such a way that we chain step3 after step2 and step2 after step1. Note that there is no explicit data dependency between these steps, but still steps can be made dependent by using the [run_after](https://docs.microsoft.com/en-us/python/api/azureml-pipeline-core/azureml.pipeline.core.builder.pipelinestep?view=azure-ml-py#run-after-step-) construct.", "_____no_output_____" ] ], [ [ "step2.run_after(step1)\nstep3.run_after(step2)\n\n# Try a loop\n#step2.run_after(step3)\n\n# Now, construct the pipeline using the steps.\n\n# We can specify the \"final step\" in the chain, \n# Pipeline will take care of \"transitive closure\" and \n# figure out the implicit or explicit dependencies\n# https://www.geeksforgeeks.org/transitive-closure-of-a-graph/\npipeline2 = Pipeline(workspace=ws, steps=[step3])\nprint (\"Pipeline is built\")\n\npipeline2.validate()\nprint(\"Simple validation complete\")", "_____no_output_____" ], [ "pipeline_run2 = Experiment(ws, 'Hello_World2').submit(pipeline2)\nprint(\"Pipeline is submitted for execution\")", "_____no_output_____" ], [ "RunDetails(pipeline_run2).show()", "_____no_output_____" ] ], [ [ "# Next: Pipelines with data dependency\nThe next [notebook](https://aka.ms/pl-data-dep) demostrates how to construct a pipeline with data dependency.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "%matplotlib inline", "_____no_output_____" ] ], [ [ "\nDCGAN Tutorial\n==============\n\n**Author**: `Nathan Inkawhich <https://github.com/inkawhich>`__\n\n\n", "_____no_output_____" ], [ "Introduction\n------------\n\nThis tutorial will give an introduction to DCGANs through an example. We\nwill train a generative adversarial network (GAN) to generate new\ncelebrities after showing it pictures of many real celebrities. Most of\nthe code here is from the dcgan implementation in\n`pytorch/examples <https://github.com/pytorch/examples>`__, and this\ndocument will give a thorough explanation of the implementation and shed\nlight on how and why this model works. But don’t worry, no prior\nknowledge of GANs is required, but it may require a first-timer to spend\nsome time reasoning about what is actually happening under the hood.\nAlso, for the sake of time it will help to have a GPU, or two. Lets\nstart from the beginning.\n\nGenerative Adversarial Networks\n-------------------------------\n\nWhat is a GAN?\n~~~~~~~~~~~~~~\n\nGANs are a framework for teaching a DL model to capture the training\ndata’s distribution so we can generate new data from that same\ndistribution. GANs were invented by Ian Goodfellow in 2014 and first\ndescribed in the paper `Generative Adversarial\nNets <https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf>`__.\nThey are made of two distinct models, a *generator* and a\n*discriminator*. The job of the generator is to spawn ‘fake’ images that\nlook like the training images. The job of the discriminator is to look\nat an image and output whether or not it is a real training image or a\nfake image from the generator. During training, the generator is\nconstantly trying to outsmart the discriminator by generating better and\nbetter fakes, while the discriminator is working to become a better\ndetective and correctly classify the real and fake images. The\nequilibrium of this game is when the generator is generating perfect\nfakes that look as if they came directly from the training data, and the\ndiscriminator is left to always guess at 50% confidence that the\ngenerator output is real or fake.\n\nNow, lets define some notation to be used throughout tutorial starting\nwith the discriminator. Let $x$ be data representing an image.\n$D(x)$ is the discriminator network which outputs the (scalar)\nprobability that $x$ came from training data rather than the\ngenerator. Here, since we are dealing with images the input to\n$D(x)$ is an image of CHW size 3x64x64. Intuitively, $D(x)$\nshould be HIGH when $x$ comes from training data and LOW when\n$x$ comes from the generator. $D(x)$ can also be thought of\nas a traditional binary classifier.\n\nFor the generator’s notation, let $z$ be a latent space vector\nsampled from a standard normal distribution. $G(z)$ represents the\ngenerator function which maps the latent vector $z$ to data-space.\nThe goal of $G$ is to estimate the distribution that the training\ndata comes from ($p_{data}$) so it can generate fake samples from\nthat estimated distribution ($p_g$).\n\nSo, $D(G(z))$ is the probability (scalar) that the output of the\ngenerator $G$ is a real image. As described in `Goodfellow’s\npaper <https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf>`__,\n$D$ and $G$ play a minimax game in which $D$ tries to\nmaximize the probability it correctly classifies reals and fakes\n($logD(x)$), and $G$ tries to minimize the probability that\n$D$ will predict its outputs are fake ($log(1-D(G(x)))$).\nFrom the paper, the GAN loss function is\n\n\\begin{align}\\underset{G}{\\text{min}} \\underset{D}{\\text{max}}V(D,G) = \\mathbb{E}_{x\\sim p_{data}(x)}\\big[logD(x)\\big] + \\mathbb{E}_{z\\sim p_{z}(z)}\\big[log(1-D(G(z)))\\big]\\end{align}\n\nIn theory, the solution to this minimax game is where\n$p_g = p_{data}$, and the discriminator guesses randomly if the\ninputs are real or fake. However, the convergence theory of GANs is\nstill being actively researched and in reality models do not always\ntrain to this point.\n\nWhat is a DCGAN?\n~~~~~~~~~~~~~~~~\n\nA DCGAN is a direct extension of the GAN described above, except that it\nexplicitly uses convolutional and convolutional-transpose layers in the\ndiscriminator and generator, respectively. It was first described by\nRadford et. al. in the paper `Unsupervised Representation Learning With\nDeep Convolutional Generative Adversarial\nNetworks <https://arxiv.org/pdf/1511.06434.pdf>`__. The discriminator\nis made up of strided\n`convolution <https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d>`__\nlayers, `batch\nnorm <https://pytorch.org/docs/stable/nn.html#torch.nn.BatchNorm2d>`__\nlayers, and\n`LeakyReLU <https://pytorch.org/docs/stable/nn.html#torch.nn.LeakyReLU>`__\nactivations. The input is a 3x64x64 input image and the output is a\nscalar probability that the input is from the real data distribution.\nThe generator is comprised of\n`convolutional-transpose <https://pytorch.org/docs/stable/nn.html#torch.nn.ConvTranspose2d>`__\nlayers, batch norm layers, and\n`ReLU <https://pytorch.org/docs/stable/nn.html#relu>`__ activations. The\ninput is a latent vector, $z$, that is drawn from a standard\nnormal distribution and the output is a 3x64x64 RGB image. The strided\nconv-transpose layers allow the latent vector to be transformed into a\nvolume with the same shape as an image. In the paper, the authors also\ngive some tips about how to setup the optimizers, how to calculate the\nloss functions, and how to initialize the model weights, all of which\nwill be explained in the coming sections.\n\n\n", "_____no_output_____" ] ], [ [ "from __future__ import print_function\n#%matplotlib inline\nimport argparse\nimport os\nimport random\nimport torch\nimport torch.nn as nn\nimport torch.nn.parallel\nimport torch.backends.cudnn as cudnn\nimport torch.optim as optim\nimport torch.utils.data\nimport torchvision.datasets as dset\nimport torchvision.transforms as transforms\nimport torchvision.utils as vutils\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.animation as animation\nfrom IPython.display import HTML\n\n# Set random seed for reproducibility\nmanualSeed = 999\n#manualSeed = random.randint(1, 10000) # use if you want new results\nprint(\"Random Seed: \", manualSeed)\nrandom.seed(manualSeed)\ntorch.manual_seed(manualSeed)", "_____no_output_____" ] ], [ [ "Inputs\n------\n\nLet’s define some inputs for the run:\n\n- **dataroot** - the path to the root of the dataset folder. We will\n talk more about the dataset in the next section\n- **workers** - the number of worker threads for loading the data with\n the DataLoader\n- **batch_size** - the batch size used in training. The DCGAN paper\n uses a batch size of 128\n- **image_size** - the spatial size of the images used for training.\n This implementation defaults to 64x64. If another size is desired,\n the structures of D and G must be changed. See\n `here <https://github.com/pytorch/examples/issues/70>`__ for more\n details\n- **nc** - number of color channels in the input images. For color\n images this is 3\n- **nz** - length of latent vector\n- **ngf** - relates to the depth of feature maps carried through the\n generator\n- **ndf** - sets the depth of feature maps propagated through the\n discriminator\n- **num_epochs** - number of training epochs to run. Training for\n longer will probably lead to better results but will also take much\n longer\n- **lr** - learning rate for training. As described in the DCGAN paper,\n this number should be 0.0002\n- **beta1** - beta1 hyperparameter for Adam optimizers. As described in\n paper, this number should be 0.5\n- **ngpu** - number of GPUs available. If this is 0, code will run in\n CPU mode. If this number is greater than 0 it will run on that number\n of GPUs\n\n\n", "_____no_output_____" ] ], [ [ "# Root directory for dataset\ndataroot = \"data/celeba\"\n\n# Number of workers for dataloader\nworkers = 2\n\n# Batch size during training\nbatch_size = 128\n\n# Spatial size of training images. All images will be resized to this\n# size using a transformer.\nimage_size = 64\n\n# Number of channels in the training images. For color images this is 3\nnc = 3\n\n# Size of z latent vector (i.e. size of generator input)\nnz = 100\n\n# Size of feature maps in generator\nngf = 64\n\n# Size of feature maps in discriminator\nndf = 64\n\n# Number of training epochs\nnum_epochs = 5\n\n# Learning rate for optimizers\nlr = 0.0002\n\n# Beta1 hyperparam for Adam optimizers\nbeta1 = 0.5\n\n# Number of GPUs available. Use 0 for CPU mode.\nngpu = 1", "_____no_output_____" ] ], [ [ "Data\n----\n\nIn this tutorial we will use the `Celeb-A Faces\ndataset <http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html>`__ which can\nbe downloaded at the linked site, or in `Google\nDrive <https://drive.google.com/drive/folders/0B7EVK8r0v71pTUZsaXdaSnZBZzg>`__.\nThe dataset will download as a file named *img_align_celeba.zip*. Once\ndownloaded, create a directory named *celeba* and extract the zip file\ninto that directory. Then, set the *dataroot* input for this notebook to\nthe *celeba* directory you just created. The resulting directory\nstructure should be:\n\n::\n\n /path/to/celeba\n -> img_align_celeba \n -> 188242.jpg\n -> 173822.jpg\n -> 284702.jpg\n -> 537394.jpg\n ...\n\nThis is an important step because we will be using the ImageFolder\ndataset class, which requires there to be subdirectories in the\ndataset’s root folder. Now, we can create the dataset, create the\ndataloader, set the device to run on, and finally visualize some of the\ntraining data.\n\n\n", "_____no_output_____" ] ], [ [ "# We can use an image folder dataset the way we have it setup.\n# Create the dataset\ndataset = dset.ImageFolder(root=dataroot,\n transform=transforms.Compose([\n transforms.Resize(image_size),\n transforms.CenterCrop(image_size),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n ]))\n# Create the dataloader\ndataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n shuffle=True, num_workers=workers)\n\n# Decide which device we want to run on\ndevice = torch.device(\"cuda:0\" if (torch.cuda.is_available() and ngpu > 0) else \"cpu\")\n\n# Plot some training images\nreal_batch = next(iter(dataloader))\nplt.figure(figsize=(8,8))\nplt.axis(\"off\")\nplt.title(\"Training Images\")\nplt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=2, normalize=True).cpu(),(1,2,0)))", "_____no_output_____" ] ], [ [ "Implementation\n--------------\n\nWith our input parameters set and the dataset prepared, we can now get\ninto the implementation. We will start with the weigth initialization\nstrategy, then talk about the generator, discriminator, loss functions,\nand training loop in detail.\n\nWeight Initialization\n~~~~~~~~~~~~~~~~~~~~~\n\nFrom the DCGAN paper, the authors specify that all model weights shall\nbe randomly initialized from a Normal distribution with mean=0,\nstdev=0.02. The ``weights_init`` function takes an initialized model as\ninput and reinitializes all convolutional, convolutional-transpose, and\nbatch normalization layers to meet this criteria. This function is\napplied to the models immediately after initialization.\n\n\n", "_____no_output_____" ] ], [ [ "# custom weights initialization called on netG and netD\ndef weights_init(m):\n classname = m.__class__.__name__\n if classname.find('Conv') != -1:\n nn.init.normal_(m.weight.data, 0.0, 0.02)\n elif classname.find('BatchNorm') != -1:\n nn.init.normal_(m.weight.data, 1.0, 0.02)\n nn.init.constant_(m.bias.data, 0)", "_____no_output_____" ] ], [ [ "Generator\n~~~~~~~~~\n\nThe generator, $G$, is designed to map the latent space vector\n($z$) to data-space. Since our data are images, converting\n$z$ to data-space means ultimately creating a RGB image with the\nsame size as the training images (i.e. 3x64x64). In practice, this is\naccomplished through a series of strided two dimensional convolutional\ntranspose layers, each paired with a 2d batch norm layer and a relu\nactivation. The output of the generator is fed through a tanh function\nto return it to the input data range of $[-1,1]$. It is worth\nnoting the existence of the batch norm functions after the\nconv-transpose layers, as this is a critical contribution of the DCGAN\npaper. These layers help with the flow of gradients during training. An\nimage of the generator from the DCGAN paper is shown below.\n\n.. figure:: /_static/img/dcgan_generator.png\n :alt: dcgan_generator\n\nNotice, the how the inputs we set in the input section (*nz*, *ngf*, and\n*nc*) influence the generator architecture in code. *nz* is the length\nof the z input vector, *ngf* relates to the size of the feature maps\nthat are propagated through the generator, and *nc* is the number of\nchannels in the output image (set to 3 for RGB images). Below is the\ncode for the generator.\n\n\n", "_____no_output_____" ] ], [ [ "# Generator Code\n\nclass Generator(nn.Module):\n def __init__(self, ngpu):\n super(Generator, self).__init__()\n self.ngpu = ngpu\n self.main = nn.Sequential(\n # input is Z, going into a convolution\n nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),\n nn.BatchNorm2d(ngf * 8),\n nn.ReLU(True),\n # state size. (ngf*8) x 4 x 4\n nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ngf * 4),\n nn.ReLU(True),\n # state size. (ngf*4) x 8 x 8\n nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ngf * 2),\n nn.ReLU(True),\n # state size. (ngf*2) x 16 x 16\n nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ngf),\n nn.ReLU(True),\n # state size. (ngf) x 32 x 32\n nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),\n nn.Tanh()\n # state size. (nc) x 64 x 64\n )\n\n def forward(self, input):\n return self.main(input)", "_____no_output_____" ] ], [ [ "Now, we can instantiate the generator and apply the ``weights_init``\nfunction. Check out the printed model to see how the generator object is\nstructured.\n\n\n", "_____no_output_____" ] ], [ [ "# Create the generator\nnetG = Generator(ngpu).to(device)\n\n# Handle multi-gpu if desired\nif (device.type == 'cuda') and (ngpu > 1):\n netG = nn.DataParallel(netG, list(range(ngpu)))\n\n# Apply the weights_init function to randomly initialize all weights\n# to mean=0, stdev=0.2.\nnetG.apply(weights_init)\n\n# Print the model\nprint(netG)", "_____no_output_____" ] ], [ [ "Discriminator\n~~~~~~~~~~~~~\n\nAs mentioned, the discriminator, $D$, is a binary classification\nnetwork that takes an image as input and outputs a scalar probability\nthat the input image is real (as opposed to fake). Here, $D$ takes\na 3x64x64 input image, processes it through a series of Conv2d,\nBatchNorm2d, and LeakyReLU layers, and outputs the final probability\nthrough a Sigmoid activation function. This architecture can be extended\nwith more layers if necessary for the problem, but there is significance\nto the use of the strided convolution, BatchNorm, and LeakyReLUs. The\nDCGAN paper mentions it is a good practice to use strided convolution\nrather than pooling to downsample because it lets the network learn its\nown pooling function. Also batch norm and leaky relu functions promote\nhealthy gradient flow which is critical for the learning process of both\n$G$ and $D$.\n\n\n", "_____no_output_____" ], [ "Discriminator Code\n\n", "_____no_output_____" ] ], [ [ "class Discriminator(nn.Module):\n def __init__(self, ngpu):\n super(Discriminator, self).__init__()\n self.ngpu = ngpu\n self.main = nn.Sequential(\n # input is (nc) x 64 x 64\n nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf) x 32 x 32\n nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 2),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*2) x 16 x 16\n nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 4),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*4) x 8 x 8\n nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 8),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*8) x 4 x 4\n nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\n nn.Sigmoid()\n )\n\n def forward(self, input):\n return self.main(input)", "_____no_output_____" ] ], [ [ "Now, as with the generator, we can create the discriminator, apply the\n``weights_init`` function, and print the model’s structure.\n\n\n", "_____no_output_____" ] ], [ [ "# Create the Discriminator\nnetD = Discriminator(ngpu).to(device)\n\n# Handle multi-gpu if desired\nif (device.type == 'cuda') and (ngpu > 1):\n netD = nn.DataParallel(netD, list(range(ngpu)))\n \n# Apply the weights_init function to randomly initialize all weights\n# to mean=0, stdev=0.2.\nnetD.apply(weights_init)\n\n# Print the model\nprint(netD)", "_____no_output_____" ] ], [ [ "Loss Functions and Optimizers\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nWith $D$ and $G$ setup, we can specify how they learn\nthrough the loss functions and optimizers. We will use the Binary Cross\nEntropy loss\n(`BCELoss <https://pytorch.org/docs/stable/nn.html#torch.nn.BCELoss>`__)\nfunction which is defined in PyTorch as:\n\n\\begin{align}\\ell(x, y) = L = \\{l_1,\\dots,l_N\\}^\\top, \\quad l_n = - \\left[ y_n \\cdot \\log x_n + (1 - y_n) \\cdot \\log (1 - x_n) \\right]\\end{align}\n\nNotice how this function provides the calculation of both log components\nin the objective function (i.e. $log(D(x))$ and\n$log(1-D(G(z)))$). We can specify what part of the BCE equation to\nuse with the $y$ input. This is accomplished in the training loop\nwhich is coming up soon, but it is important to understand how we can\nchoose which component we wish to calculate just by changing $y$\n(i.e. GT labels).\n\nNext, we define our real label as 1 and the fake label as 0. These\nlabels will be used when calculating the losses of $D$ and\n$G$, and this is also the convention used in the original GAN\npaper. Finally, we set up two separate optimizers, one for $D$ and\none for $G$. As specified in the DCGAN paper, both are Adam\noptimizers with learning rate 0.0002 and Beta1 = 0.5. For keeping track\nof the generator’s learning progression, we will generate a fixed batch\nof latent vectors that are drawn from a Gaussian distribution\n(i.e. fixed_noise) . In the training loop, we will periodically input\nthis fixed_noise into $G$, and over the iterations we will see\nimages form out of the noise.\n\n\n", "_____no_output_____" ] ], [ [ "# Initialize BCELoss function\ncriterion = nn.BCELoss()\n\n# Create batch of latent vectors that we will use to visualize\n# the progression of the generator\nfixed_noise = torch.randn(64, nz, 1, 1, device=device)\n\n# Establish convention for real and fake labels during training\nreal_label = 1.\nfake_label = 0.\n\n# Setup Adam optimizers for both G and D\noptimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))\noptimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))", "_____no_output_____" ] ], [ [ "Training\n~~~~~~~~\n\nFinally, now that we have all of the parts of the GAN framework defined,\nwe can train it. Be mindful that training GANs is somewhat of an art\nform, as incorrect hyperparameter settings lead to mode collapse with\nlittle explanation of what went wrong. Here, we will closely follow\nAlgorithm 1 from Goodfellow’s paper, while abiding by some of the best\npractices shown in `ganhacks <https://github.com/soumith/ganhacks>`__.\nNamely, we will “construct different mini-batches for real and fake”\nimages, and also adjust G’s objective function to maximize\n$logD(G(z))$. Training is split up into two main parts. Part 1\nupdates the Discriminator and Part 2 updates the Generator.\n\n**Part 1 - Train the Discriminator**\n\nRecall, the goal of training the discriminator is to maximize the\nprobability of correctly classifying a given input as real or fake. In\nterms of Goodfellow, we wish to “update the discriminator by ascending\nits stochastic gradient”. Practically, we want to maximize\n$log(D(x)) + log(1-D(G(z)))$. Due to the separate mini-batch\nsuggestion from ganhacks, we will calculate this in two steps. First, we\nwill construct a batch of real samples from the training set, forward\npass through $D$, calculate the loss ($log(D(x))$), then\ncalculate the gradients in a backward pass. Secondly, we will construct\na batch of fake samples with the current generator, forward pass this\nbatch through $D$, calculate the loss ($log(1-D(G(z)))$),\nand *accumulate* the gradients with a backward pass. Now, with the\ngradients accumulated from both the all-real and all-fake batches, we\ncall a step of the Discriminator’s optimizer.\n\n**Part 2 - Train the Generator**\n\nAs stated in the original paper, we want to train the Generator by\nminimizing $log(1-D(G(z)))$ in an effort to generate better fakes.\nAs mentioned, this was shown by Goodfellow to not provide sufficient\ngradients, especially early in the learning process. As a fix, we\ninstead wish to maximize $log(D(G(z)))$. In the code we accomplish\nthis by: classifying the Generator output from Part 1 with the\nDiscriminator, computing G’s loss *using real labels as GT*, computing\nG’s gradients in a backward pass, and finally updating G’s parameters\nwith an optimizer step. It may seem counter-intuitive to use the real\nlabels as GT labels for the loss function, but this allows us to use the\n$log(x)$ part of the BCELoss (rather than the $log(1-x)$\npart) which is exactly what we want.\n\nFinally, we will do some statistic reporting and at the end of each\nepoch we will push our fixed_noise batch through the generator to\nvisually track the progress of G’s training. The training statistics\nreported are:\n\n- **Loss_D** - discriminator loss calculated as the sum of losses for\n the all real and all fake batches ($log(D(x)) + log(D(G(z)))$).\n- **Loss_G** - generator loss calculated as $log(D(G(z)))$\n- **D(x)** - the average output (across the batch) of the discriminator\n for the all real batch. This should start close to 1 then\n theoretically converge to 0.5 when G gets better. Think about why\n this is.\n- **D(G(z))** - average discriminator outputs for the all fake batch.\n The first number is before D is updated and the second number is\n after D is updated. These numbers should start near 0 and converge to\n 0.5 as G gets better. Think about why this is.\n\n**Note:** This step might take a while, depending on how many epochs you\nrun and if you removed some data from the dataset.\n\n\n", "_____no_output_____" ] ], [ [ "# Training Loop\n\n# Lists to keep track of progress\nimg_list = []\nG_losses = []\nD_losses = []\niters = 0\n\nprint(\"Starting Training Loop...\")\n# For each epoch\nfor epoch in range(num_epochs):\n # For each batch in the dataloader\n for i, data in enumerate(dataloader, 0):\n \n ############################\n # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n ###########################\n ## Train with all-real batch\n netD.zero_grad()\n # Format batch\n real_cpu = data[0].to(device)\n b_size = real_cpu.size(0)\n label = torch.full((b_size,), real_label, dtype=torch.float, device=device)\n # Forward pass real batch through D\n output = netD(real_cpu).view(-1)\n # Calculate loss on all-real batch\n errD_real = criterion(output, label)\n # Calculate gradients for D in backward pass\n errD_real.backward()\n D_x = output.mean().item()\n\n ## Train with all-fake batch\n # Generate batch of latent vectors\n noise = torch.randn(b_size, nz, 1, 1, device=device)\n # Generate fake image batch with G\n fake = netG(noise)\n label.fill_(fake_label)\n # Classify all fake batch with D\n output = netD(fake.detach()).view(-1)\n # Calculate D's loss on the all-fake batch\n errD_fake = criterion(output, label)\n # Calculate the gradients for this batch\n errD_fake.backward()\n D_G_z1 = output.mean().item()\n # Add the gradients from the all-real and all-fake batches\n errD = errD_real + errD_fake\n # Update D\n optimizerD.step()\n\n ############################\n # (2) Update G network: maximize log(D(G(z)))\n ###########################\n netG.zero_grad()\n label.fill_(real_label) # fake labels are real for generator cost\n # Since we just updated D, perform another forward pass of all-fake batch through D\n output = netD(fake).view(-1)\n # Calculate G's loss based on this output\n errG = criterion(output, label)\n # Calculate gradients for G\n errG.backward()\n D_G_z2 = output.mean().item()\n # Update G\n optimizerG.step()\n \n # Output training stats\n if i % 50 == 0:\n print('[%d/%d][%d/%d]\\tLoss_D: %.4f\\tLoss_G: %.4f\\tD(x): %.4f\\tD(G(z)): %.4f / %.4f'\n % (epoch, num_epochs, i, len(dataloader),\n errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))\n \n # Save Losses for plotting later\n G_losses.append(errG.item())\n D_losses.append(errD.item())\n \n # Check how the generator is doing by saving G's output on fixed_noise\n if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):\n with torch.no_grad():\n fake = netG(fixed_noise).detach().cpu()\n img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n \n iters += 1", "_____no_output_____" ] ], [ [ "Results\n-------\n\nFinally, lets check out how we did. Here, we will look at three\ndifferent results. First, we will see how D and G’s losses changed\nduring training. Second, we will visualize G’s output on the fixed_noise\nbatch for every epoch. And third, we will look at a batch of real data\nnext to a batch of fake data from G.\n\n**Loss versus training iteration**\n\nBelow is a plot of D & G’s losses versus training iterations.\n\n\n", "_____no_output_____" ] ], [ [ "plt.figure(figsize=(10,5))\nplt.title(\"Generator and Discriminator Loss During Training\")\nplt.plot(G_losses,label=\"G\")\nplt.plot(D_losses,label=\"D\")\nplt.xlabel(\"iterations\")\nplt.ylabel(\"Loss\")\nplt.legend()\nplt.show()", "_____no_output_____" ] ], [ [ "**Visualization of G’s progression**\n\nRemember how we saved the generator’s output on the fixed_noise batch\nafter every epoch of training. Now, we can visualize the training\nprogression of G with an animation. Press the play button to start the\nanimation.\n\n\n", "_____no_output_____" ] ], [ [ "#%%capture\nfig = plt.figure(figsize=(8,8))\nplt.axis(\"off\")\nims = [[plt.imshow(np.transpose(i,(1,2,0)), animated=True)] for i in img_list]\nani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)\n\nHTML(ani.to_jshtml())", "_____no_output_____" ] ], [ [ "**Real Images vs. Fake Images**\n\nFinally, lets take a look at some real images and fake images side by\nside.\n\n\n", "_____no_output_____" ] ], [ [ "# Grab a batch of real images from the dataloader\nreal_batch = next(iter(dataloader))\n\n# Plot the real images\nplt.figure(figsize=(15,15))\nplt.subplot(1,2,1)\nplt.axis(\"off\")\nplt.title(\"Real Images\")\nplt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=5, normalize=True).cpu(),(1,2,0)))\n\n# Plot the fake images from the last epoch\nplt.subplot(1,2,2)\nplt.axis(\"off\")\nplt.title(\"Fake Images\")\nplt.imshow(np.transpose(img_list[-1],(1,2,0)))\nplt.show()", "_____no_output_____" ] ], [ [ "Where to Go Next\n----------------\n\nWe have reached the end of our journey, but there are several places you\ncould go from here. You could:\n\n- Train for longer to see how good the results get\n- Modify this model to take a different dataset and possibly change the\n size of the images and the model architecture\n- Check out some other cool GAN projects\n `here <https://github.com/nashory/gans-awesome-applications>`__\n- Create GANs that generate\n `music <https://deepmind.com/blog/wavenet-generative-model-raw-audio/>`__\n\n\n", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "!pip install tensorflow-gpu==1.15.3", "Collecting tensorflow-gpu==1.15.3\n\u001b[?25l Downloading https://files.pythonhosted.org/packages/32/d9/f977cb032856d7f65cc42541da1ff12dafc4ff35fddb819836cf5c4cab60/tensorflow_gpu-1.15.3-cp37-cp37m-manylinux2010_x86_64.whl (411.0MB)\n\u001b[K |████████████████████████████████| 411.0MB 43kB/s \n\u001b[?25hRequirement already satisfied: astor>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (0.8.1)\nCollecting tensorboard<1.16.0,>=1.15.0\n\u001b[?25l Downloading https://files.pythonhosted.org/packages/1e/e9/d3d747a97f7188f48aa5eda486907f3b345cd409f0a0850468ba867db246/tensorboard-1.15.0-py3-none-any.whl (3.8MB)\n\u001b[K |████████████████████████████████| 3.8MB 44.6MB/s \n\u001b[?25hRequirement already satisfied: google-pasta>=0.1.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (0.2.0)\nRequirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (0.10.0)\nRequirement already satisfied: keras-preprocessing>=1.0.5 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (1.1.2)\nCollecting tensorflow-estimator==1.15.1\n\u001b[?25l Downloading https://files.pythonhosted.org/packages/de/62/2ee9cd74c9fa2fa450877847ba560b260f5d0fb70ee0595203082dafcc9d/tensorflow_estimator-1.15.1-py2.py3-none-any.whl (503kB)\n\u001b[K |████████████████████████████████| 512kB 52.7MB/s \n\u001b[?25hRequirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (1.15.0)\nRequirement already satisfied: protobuf>=3.6.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (3.12.4)\nRequirement already satisfied: numpy<2.0,>=1.16.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (1.19.5)\nCollecting keras-applications>=1.0.8\n\u001b[?25l Downloading https://files.pythonhosted.org/packages/71/e3/19762fdfc62877ae9102edf6342d71b28fbfd9dea3d2f96a882ce099b03f/Keras_Applications-1.0.8-py3-none-any.whl (50kB)\n\u001b[K |████████████████████████████████| 51kB 9.5MB/s \n\u001b[?25hRequirement already satisfied: grpcio>=1.8.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (1.32.0)\nRequirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (1.12.1)\nRequirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (3.3.0)\nRequirement already satisfied: wheel>=0.26; python_version >= \"3\" in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (0.36.2)\nCollecting gast==0.2.2\n Downloading https://files.pythonhosted.org/packages/4e/35/11749bf99b2d4e3cceb4d55ca22590b0d7c2c62b9de38ac4a4a7f4687421/gast-0.2.2.tar.gz\nRequirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow-gpu==1.15.3) (1.1.0)\nRequirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard<1.16.0,>=1.15.0->tensorflow-gpu==1.15.3) (1.0.1)\nRequirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard<1.16.0,>=1.15.0->tensorflow-gpu==1.15.3) (3.3.3)\nRequirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<1.16.0,>=1.15.0->tensorflow-gpu==1.15.3) (53.0.0)\nRequirement already satisfied: h5py in /usr/local/lib/python3.7/dist-packages (from keras-applications>=1.0.8->tensorflow-gpu==1.15.3) (2.10.0)\nRequirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard<1.16.0,>=1.15.0->tensorflow-gpu==1.15.3) (3.4.0)\nRequirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<1.16.0,>=1.15.0->tensorflow-gpu==1.15.3) (3.4.0)\nRequirement already satisfied: typing-extensions>=3.6.4; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<1.16.0,>=1.15.0->tensorflow-gpu==1.15.3) (3.7.4.3)\nBuilding wheels for collected packages: gast\n Building wheel for gast (setup.py) ... \u001b[?25l\u001b[?25hdone\n Created wheel for gast: filename=gast-0.2.2-cp37-none-any.whl size=7540 sha256=4f77183c26d45864469072876cb7997af7c3d564abebfcb08b153eb5eecf2359\n Stored in directory: /root/.cache/pip/wheels/5c/2e/7e/a1d4d4fcebe6c381f378ce7743a3ced3699feb89bcfbdadadd\nSuccessfully built gast\n\u001b[31mERROR: tensorflow 2.4.1 has requirement gast==0.3.3, but you'll have gast 0.2.2 which is incompatible.\u001b[0m\n\u001b[31mERROR: tensorflow 2.4.1 has requirement tensorboard~=2.4, but you'll have tensorboard 1.15.0 which is incompatible.\u001b[0m\n\u001b[31mERROR: tensorflow 2.4.1 has requirement tensorflow-estimator<2.5.0,>=2.4.0, but you'll have tensorflow-estimator 1.15.1 which is incompatible.\u001b[0m\n\u001b[31mERROR: tensorflow-probability 0.12.1 has requirement gast>=0.3.2, but you'll have gast 0.2.2 which is incompatible.\u001b[0m\nInstalling collected packages: tensorboard, tensorflow-estimator, keras-applications, gast, tensorflow-gpu\n Found existing installation: tensorboard 2.4.1\n Uninstalling tensorboard-2.4.1:\n Successfully uninstalled tensorboard-2.4.1\n Found existing installation: tensorflow-estimator 2.4.0\n Uninstalling tensorflow-estimator-2.4.0:\n Successfully uninstalled tensorflow-estimator-2.4.0\n Found existing installation: gast 0.3.3\n Uninstalling gast-0.3.3:\n Successfully uninstalled gast-0.3.3\nSuccessfully installed gast-0.2.2 keras-applications-1.0.8 tensorboard-1.15.0 tensorflow-estimator-1.15.1 tensorflow-gpu-1.15.3\n" ], [ "!pip install Keras==2.1.5", "Collecting Keras==2.1.5\n\u001b[?25l Downloading https://files.pythonhosted.org/packages/ba/65/e4aff762b8696ec0626a6654b1e73b396fcc8b7cc6b98d78a1bc53b85b48/Keras-2.1.5-py2.py3-none-any.whl (334kB)\n\r\u001b[K |█ | 10kB 20.7MB/s eta 0:00:01\r\u001b[K |██ | 20kB 14.1MB/s eta 0:00:01\r\u001b[K |███ | 30kB 12.9MB/s eta 0:00:01\r\u001b[K |████ | 40kB 12.0MB/s eta 0:00:01\r\u001b[K |█████ | 51kB 7.5MB/s eta 0:00:01\r\u001b[K |█████▉ | 61kB 7.9MB/s eta 0:00:01\r\u001b[K |██████▉ | 71kB 8.9MB/s eta 0:00:01\r\u001b[K |███████▉ | 81kB 9.2MB/s eta 0:00:01\r\u001b[K |████████▉ | 92kB 9.1MB/s eta 0:00:01\r\u001b[K |█████████▉ | 102kB 8.4MB/s eta 0:00:01\r\u001b[K |██████████▊ | 112kB 8.4MB/s eta 0:00:01\r\u001b[K |███████████▊ | 122kB 8.4MB/s eta 0:00:01\r\u001b[K |████████████▊ | 133kB 8.4MB/s eta 0:00:01\r\u001b[K |█████████████▊ | 143kB 8.4MB/s eta 0:00:01\r\u001b[K |██████████████▊ | 153kB 8.4MB/s eta 0:00:01\r\u001b[K |███████████████▋ | 163kB 8.4MB/s eta 0:00:01\r\u001b[K |████████████████▋ | 174kB 8.4MB/s eta 0:00:01\r\u001b[K |█████████████████▋ | 184kB 8.4MB/s eta 0:00:01\r\u001b[K |██████████████████▋ | 194kB 8.4MB/s eta 0:00:01\r\u001b[K |███████████████████▋ | 204kB 8.4MB/s eta 0:00:01\r\u001b[K |████████████████████▌ | 215kB 8.4MB/s eta 0:00:01\r\u001b[K |█████████████████████▌ | 225kB 8.4MB/s eta 0:00:01\r\u001b[K |██████████████████████▌ | 235kB 8.4MB/s eta 0:00:01\r\u001b[K |███████████████████████▌ | 245kB 8.4MB/s eta 0:00:01\r\u001b[K |████████████████████████▌ | 256kB 8.4MB/s eta 0:00:01\r\u001b[K |█████████████████████████▍ | 266kB 8.4MB/s eta 0:00:01\r\u001b[K |██████████████████████████▍ | 276kB 8.4MB/s eta 0:00:01\r\u001b[K |███████████████████████████▍ | 286kB 8.4MB/s eta 0:00:01\r\u001b[K |████████████████████████████▍ | 296kB 8.4MB/s eta 0:00:01\r\u001b[K |█████████████████████████████▍ | 307kB 8.4MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▎ | 317kB 8.4MB/s eta 0:00:01\r\u001b[K |███████████████████████████████▎| 327kB 8.4MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 337kB 8.4MB/s \n\u001b[?25hRequirement already satisfied: six>=1.9.0 in /usr/local/lib/python3.7/dist-packages (from Keras==2.1.5) (1.15.0)\nRequirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from Keras==2.1.5) (3.13)\nRequirement already satisfied: numpy>=1.9.1 in /usr/local/lib/python3.7/dist-packages (from Keras==2.1.5) (1.19.5)\nRequirement already satisfied: scipy>=0.14 in /usr/local/lib/python3.7/dist-packages (from Keras==2.1.5) (1.4.1)\nInstalling collected packages: Keras\n Found existing installation: Keras 2.4.3\n Uninstalling Keras-2.4.3:\n Successfully uninstalled Keras-2.4.3\nSuccessfully installed Keras-2.1.5\n" ], [ "!git clone https://github.com/worldstar/keras-yolo3.git", "Cloning into 'keras-yolo3'...\nremote: Enumerating objects: 144, done.\u001b[K\nremote: Total 144 (delta 0), reused 0 (delta 0), pack-reused 144\u001b[K\nReceiving objects: 100% (144/144), 151.08 KiB | 604.00 KiB/s, done.\nResolving deltas: 100% (65/65), done.\n" ], [ "%cd keras-yolo3", "/content/keras-yolo3\n" ], [ "!wget https://pjreddie.com/media/files/yolov3.weights yolov3.weights\n!python convert.py yolov3.cfg yolov3.weights model_data/yolo_weights.h5", "_____no_output_____" ], [ "!git clone https://github.com/worldstar/dataset.git", "Cloning into 'dataset'...\nremote: Enumerating objects: 713, done.\u001b[K\nremote: Total 713 (delta 0), reused 0 (delta 0), pack-reused 713\u001b[K\nReceiving objects: 100% (713/713), 7.26 MiB | 12.63 MiB/s, done.\nResolving deltas: 100% (341/341), done.\n" ], [ "fw = open('model_data/voc_classes.txt', \"w\")\nfw.write('RBC')\nfw.close()", "_____no_output_____" ], [ "import xml.etree.ElementTree as ET\nimport os\nfrom os import getcwd\nimport sys\n\ndef generateAnnotations(path, imagePath, writePath, voc_classes):\n # path = sys.argv[1] #\"./Data/Annotations/\"\n # imagePath = sys.argv[2]#\"./Data/JPEGImages/\"\n # writePath = sys.argv[3]#\"./model_data/train.txt\"\n deputyFileName = \"jpg\"\n # classes = [\"bicycle\",\"car\",\"cat\",\"dog\",\"person\"]\n fr = open(voc_classes, 'r')#\"model_data/voc_classes.txt\"\n classes = fr.read().split(\"\\n\")\n fr.close()\n\n fw = open(writePath, \"w\")\n for fileName in os.listdir(path):\n if fileName in \".gitignore\":\n continue\n print(\"readFile:\",(path+fileName))\n convertResult = convert_annotation((path+fileName),classes,imagePath,deputyFileName)\n fw.write(convertResult)\n fw.close()\n\ndef dataUs(infos):\n return infos.split(\".\")[0]\n\ndef convert_annotation(path,classes,imagePath,deputyFileName): \n try: \n xmlFile = open(path) \n except:\n xmlFile = open(path,encoding=\"utf-8\") \n xmlTree = ET.parse(xmlFile)\n xmlRoot = xmlTree.getroot()\n width,height,depth = -1,-1,-1\n hasClass = False\n result = \"\"\n for xmlObj in xmlRoot.iter('size'):\n width = xmlObj.find('width').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")\n height = xmlObj.find('height').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\").replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")\n depth = xmlObj.find('depth').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")\n # print(width,height,depth)\n for xmlObj in xmlRoot.iter('object'):\n name = xmlObj.find('name').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")\n isClass = False\n classNum = -1\n for i in range(0,len(classes),1):\n if(name == classes[i]):\n isClass = True\n hasClass = True\n classNum = i\n if(isClass):\n xmin , ymin , xmax , ymax = -1 , -1 , -1 , -1\n for xmlObj2 in xmlObj.iter('bndbox'):\n xmin = int(dataUs(xmlObj2.find('xmin').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\").replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")))\n ymin = int(dataUs(xmlObj2.find('ymin').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")))\n xmax = int(dataUs(xmlObj2.find('xmax').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")))\n ymax = int(dataUs(xmlObj2.find('ymax').text.replace(\" \", \"\").replace(\"\\t\", \"\").replace(\"\\n\", \"\")))\n result += \" %s,%s,%s,%s,%d\"%(xmin,ymin,xmax,ymax,classNum)\n if(hasClass):\n FileName = os.path.basename(path)\n FileName = os.path.splitext(FileName)[0]\n FileName = FileName+\".\"+deputyFileName\n result = \"%s%s\\n\"%((imagePath + FileName),result)\n return result", "_____no_output_____" ], [ "generateAnnotations('dataset/Annotations/', 'dataset/JPEGImages/', 'train.txt', 'model_data/voc_classes.txt')", "_____no_output_____" ], [ "!python train.py #WPlease note there are two stages, the first stage runs 20 epochs and the 2nd stage executes 100 epochs.", "Using TensorFlow backend.\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:88: The name tf.reset_default_graph is deprecated. Please use tf.compat.v1.reset_default_graph instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:91: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:95: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:507: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:3831: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:167: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:174: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:179: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n\n2021-02-25 03:44:13.524316: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA\n2021-02-25 03:44:13.529010: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 2199995000 Hz\n2021-02-25 03:44:13.529214: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x562fbe8fea00 initialized for platform Host (this does not guarantee that XLA will be used). Devices:\n2021-02-25 03:44:13.529243: I tensorflow/compiler/xla/service/service.cc:176] StreamExecutor device (0): Host, Default Version\n2021-02-25 03:44:13.530934: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcuda.so.1\n2021-02-25 03:44:13.666199: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:983] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2021-02-25 03:44:13.666920: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x562fbe8ffb80 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n2021-02-25 03:44:13.666956: I tensorflow/compiler/xla/service/service.cc:176] StreamExecutor device (0): Tesla T4, Compute Capability 7.5\n2021-02-25 03:44:13.667113: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:983] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2021-02-25 03:44:13.667645: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1639] Found device 0 with properties: \nname: Tesla T4 major: 7 minor: 5 memoryClockRate(GHz): 1.59\npciBusID: 0000:00:04.0\n2021-02-25 03:44:13.667952: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.0\n2021-02-25 03:44:13.669073: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10.0\n2021-02-25 03:44:13.670101: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcufft.so.10.0\n2021-02-25 03:44:13.670565: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcurand.so.10.0\n2021-02-25 03:44:13.671984: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusolver.so.10.0\n2021-02-25 03:44:13.672965: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcusparse.so.10.0\n2021-02-25 03:44:13.675952: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7\n2021-02-25 03:44:13.676052: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:983] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2021-02-25 03:44:13.676586: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:983] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2021-02-25 03:44:13.677097: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1767] Adding visible gpu devices: 0\n2021-02-25 03:44:13.677152: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.0\n2021-02-25 03:44:13.678101: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1180] Device interconnect StreamExecutor with strength 1 edge matrix:\n2021-02-25 03:44:13.678127: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1186] 0 \n2021-02-25 03:44:13.678139: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1199] 0: N \n2021-02-25 03:44:13.678241: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:983] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2021-02-25 03:44:13.678792: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:983] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n2021-02-25 03:44:13.679385: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:39] Overriding allow_growth setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n2021-02-25 03:44:13.679440: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1325] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14257 MB memory) -> physical GPU (device: 0, name: Tesla T4, pci bus id: 0000:00:04.0, compute capability: 7.5)\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:183: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:192: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:199: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:1797: The name tf.nn.fused_batch_norm is deprecated. Please use tf.compat.v1.nn.fused_batch_norm instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:1940: The name tf.image.resize_nearest_neighbor is deprecated. Please use tf.compat.v1.image.resize_nearest_neighbor instead.\n\nCreate YOLOv3 model with 9 anchors and 1 classes.\n/usr/local/lib/python3.7/dist-packages/keras/engine/topology.py:3462: UserWarning: Skipping loading of weights for layer conv2d_59 due to mismatch in shape ((1, 1, 1024, 18) vs (255, 1024, 1, 1)).\n weight_values[i].shape))\n/usr/local/lib/python3.7/dist-packages/keras/engine/topology.py:3462: UserWarning: Skipping loading of weights for layer conv2d_59 due to mismatch in shape ((18,) vs (255,)).\n weight_values[i].shape))\n/usr/local/lib/python3.7/dist-packages/keras/engine/topology.py:3462: UserWarning: Skipping loading of weights for layer conv2d_67 due to mismatch in shape ((1, 1, 512, 18) vs (255, 512, 1, 1)).\n weight_values[i].shape))\n/usr/local/lib/python3.7/dist-packages/keras/engine/topology.py:3462: UserWarning: Skipping loading of weights for layer conv2d_67 due to mismatch in shape ((18,) vs (255,)).\n weight_values[i].shape))\n/usr/local/lib/python3.7/dist-packages/keras/engine/topology.py:3462: UserWarning: Skipping loading of weights for layer conv2d_75 due to mismatch in shape ((1, 1, 256, 18) vs (255, 256, 1, 1)).\n weight_values[i].shape))\n/usr/local/lib/python3.7/dist-packages/keras/engine/topology.py:3462: UserWarning: Skipping loading of weights for layer conv2d_75 due to mismatch in shape ((18,) vs (255,)).\n weight_values[i].shape))\nLoad weights model_data/yolo_weights.h5.\nFreeze the first 249 layers of total 252 layers.\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:1486: The name tf.log is deprecated. Please use tf.math.log instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:2836: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\nInstructions for updating:\nUse tf.where in 2.0, which has the same broadcast rule as np.where\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/optimizers.py:757: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n\nTrain on 309 samples, val on 34 samples, with batch size 16.\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:976: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/backend/tensorflow_backend.py:963: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/callbacks.py:774: The name tf.summary.merge_all is deprecated. Please use tf.compat.v1.summary.merge_all instead.\n\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/callbacks.py:777: The name tf.summary.FileWriter is deprecated. Please use tf.compat.v1.summary.FileWriter instead.\n\nEpoch 1/20\n2021-02-25 03:44:28.128617: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] shape_optimizer failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n2021-02-25 03:44:28.420652: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] layout failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n2021-02-25 03:44:28.702620: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] shape_optimizer failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n2021-02-25 03:44:29.701408: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudnn.so.7\n2021-02-25 03:44:31.382347: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcublas.so.10.0\n18/19 [===========================>..] - ETA: 1s - loss: 3457.29042021-02-25 03:44:52.449103: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] layout failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n19/19 [==============================] - 29s 2s/step - loss: 3334.5453 - val_loss: 993.4081\nWARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/callbacks.py:860: The name tf.Summary is deprecated. Please use tf.compat.v1.Summary instead.\n\nEpoch 2/20\n19/19 [==============================] - 23s 1s/step - loss: 625.5499 - val_loss: 372.0052\nEpoch 3/20\n19/19 [==============================] - 23s 1s/step - loss: 324.7218 - val_loss: 260.7542\nEpoch 4/20\n19/19 [==============================] - 16s 866ms/step - loss: 244.0774 - val_loss: 219.9932\nEpoch 5/20\n19/19 [==============================] - 23s 1s/step - loss: 207.5831 - val_loss: 180.8676\nEpoch 6/20\n19/19 [==============================] - 23s 1s/step - loss: 182.1875 - val_loss: 161.9958\nEpoch 7/20\n19/19 [==============================] - 23s 1s/step - loss: 167.5140 - val_loss: 148.1277\nEpoch 8/20\n19/19 [==============================] - 23s 1s/step - loss: 151.2248 - val_loss: 143.1213\nEpoch 9/20\n19/19 [==============================] - 23s 1s/step - loss: 142.6097 - val_loss: 136.3236\nEpoch 10/20\n19/19 [==============================] - 23s 1s/step - loss: 135.1423 - val_loss: 124.0489\nEpoch 11/20\n19/19 [==============================] - 23s 1s/step - loss: 128.4324 - val_loss: 119.1641\nEpoch 12/20\n19/19 [==============================] - 23s 1s/step - loss: 125.2811 - val_loss: 117.8455\nEpoch 13/20\n19/19 [==============================] - 23s 1s/step - loss: 121.7488 - val_loss: 110.1949\nEpoch 14/20\n19/19 [==============================] - 23s 1s/step - loss: 114.2375 - val_loss: 109.3775\nEpoch 15/20\n19/19 [==============================] - 23s 1s/step - loss: 112.9564 - val_loss: 106.6571\nEpoch 16/20\n19/19 [==============================] - 23s 1s/step - loss: 111.4869 - val_loss: 105.0343\nEpoch 17/20\n19/19 [==============================] - 23s 1s/step - loss: 108.5488 - val_loss: 98.9898\nEpoch 18/20\n19/19 [==============================] - 23s 1s/step - loss: 105.6998 - val_loss: 99.1945\nEpoch 19/20\n19/19 [==============================] - 23s 1s/step - loss: 104.0442 - val_loss: 94.9579\nEpoch 20/20\n19/19 [==============================] - 23s 1s/step - loss: 101.2193 - val_loss: 100.2676\nUnfreeze all of the layers.\nTrain on 309 samples, val on 34 samples, with batch size 16.\nEpoch 21/100\n2021-02-25 03:52:57.336490: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] shape_optimizer failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n2021-02-25 03:52:59.403652: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] layout failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n2021-02-25 03:53:00.909915: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] shape_optimizer failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n18/19 [===========================>..] - ETA: 1s - loss: 73.33162021-02-25 03:53:31.074251: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:533] layout failed: Invalid argument: Subshape must have computed start >= end since stride is negative, but is 0 and 2 (computed from start 0 and end 9223372036854775807 over shape with rank 2 and stride-1)\n19/19 [==============================] - 40s 2s/step - loss: 72.7146 - val_loss: 67.2190\nEpoch 22/100\n19/19 [==============================] - 26s 1s/step - loss: 63.0159 - val_loss: 64.6116\nEpoch 23/100\n19/19 [==============================] - 26s 1s/step - loss: 58.7156 - val_loss: 57.9178\nEpoch 24/100\n19/19 [==============================] - 28s 1s/step - loss: 58.1431 - val_loss: 55.3014\nEpoch 25/100\n19/19 [==============================] - 28s 1s/step - loss: 56.7163 - val_loss: 58.5629\nEpoch 26/100\n19/19 [==============================] - 28s 1s/step - loss: 54.6510 - val_loss: 54.9712\nEpoch 27/100\n19/19 [==============================] - 28s 1s/step - loss: 54.4398 - val_loss: 51.6599\nEpoch 28/100\n19/19 [==============================] - 28s 1s/step - loss: 53.8172 - val_loss: 54.9441\nEpoch 29/100\n19/19 [==============================] - 28s 1s/step - loss: 52.9516 - val_loss: 55.0698\nEpoch 30/100\n19/19 [==============================] - 28s 1s/step - loss: 53.5554 - val_loss: 53.2384\nEpoch 31/100\n19/19 [==============================] - 28s 1s/step - loss: 52.9168 - val_loss: 54.8878\n\nEpoch 00031: ReduceLROnPlateau reducing learning rate to 9.999999747378752e-06.\nEpoch 32/100\n19/19 [==============================] - 27s 1s/step - loss: 51.4068 - val_loss: 54.6203\nEpoch 33/100\n19/19 [==============================] - 28s 1s/step - loss: 50.7900 - val_loss: 53.3654\nEpoch 34/100\n19/19 [==============================] - 28s 1s/step - loss: 51.1515 - val_loss: 53.7723\n\nEpoch 00034: ReduceLROnPlateau reducing learning rate to 9.999999747378752e-07.\nEpoch 35/100\n19/19 [==============================] - 28s 1s/step - loss: 50.9989 - val_loss: 49.4049\nEpoch 36/100\n19/19 [==============================] - 28s 1s/step - loss: 51.5877 - val_loss: 51.6969\nEpoch 37/100\n19/19 [==============================] - 28s 1s/step - loss: 50.6508 - val_loss: 52.0544\nEpoch 38/100\n19/19 [==============================] - 28s 1s/step - loss: 51.2635 - val_loss: 48.1271\nEpoch 39/100\n19/19 [==============================] - 28s 1s/step - loss: 51.0648 - val_loss: 52.7201\nEpoch 40/100\n19/19 [==============================] - 28s 1s/step - loss: 51.0443 - val_loss: 53.4587\nEpoch 41/100\n19/19 [==============================] - 28s 1s/step - loss: 50.3224 - val_loss: 50.5345\nEpoch 42/100\n19/19 [==============================] - 28s 1s/step - loss: 51.3830 - val_loss: 49.8061\n\nEpoch 00042: ReduceLROnPlateau reducing learning rate to 9.999999974752428e-08.\nEpoch 43/100\n19/19 [==============================] - 28s 1s/step - loss: 51.0624 - val_loss: 51.8863\nEpoch 44/100\n19/19 [==============================] - 28s 1s/step - loss: 51.0018 - val_loss: 51.3152\nEpoch 45/100\n19/19 [==============================] - 28s 1s/step - loss: 50.3419 - val_loss: 53.4304\n\nEpoch 00045: ReduceLROnPlateau reducing learning rate to 1.0000000116860975e-08.\nEpoch 46/100\n19/19 [==============================] - 28s 1s/step - loss: 50.4961 - val_loss: 50.0752\nEpoch 47/100\n19/19 [==============================] - 28s 1s/step - loss: 50.7682 - val_loss: 51.7997\nEpoch 48/100\n19/19 [==============================] - 28s 1s/step - loss: 50.8429 - val_loss: 53.9532\n\nEpoch 00048: ReduceLROnPlateau reducing learning rate to 9.999999939225292e-10.\nEpoch 00048: early stopping\n" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy as np\nimport scipy.misc\nfrom scipy.fftpack import dct, idct\nimport sys\nfrom PIL import Image\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport random\nfrom tqdm._tqdm_notebook import tqdm_notebook\nfrom scipy.fftpack import dct, idct\nimport seaborn as sns\nfrom skimage.metrics import structural_similarity as ssim\nimport pandas as pd\nimport sympy\n\n%matplotlib inline\n\n\nclass ImageLoader:\n def __init__(self, FILE_PATH):\n self.img = np.array(Image.open(FILE_PATH))\n # 行数\n self.row_blocks_count = self.img.shape[0] // 8\n # 列数\n self.col_blocks_count = self.img.shape[1] // 8\n\n def get_points(self, POINT):\n Row = random.randint(0, len(self.img) - POINT - 1)\n Col = random.randint(0, len(self.img) - 1)\n return self.img[Row : Row + POINT, Col]\n\n def get_block(self, col, row):\n return self.img[col * 8 : (col + 1) * 8, row * 8 : (row + 1) * 8]\n\n\n# plt.rcParams['font.family'] ='sans-serif'#使用するフォント\n# plt.rcParams[\"font.sans-serif\"] = \"Source Han Sans\"\nplt.rcParams[\"font.family\"] = \"Source Han Sans JP\" # 使用するフォント\nplt.rcParams[\"xtick.direction\"] = \"in\" # x軸の目盛線が内向き('in')か外向き('out')か双方向か('inout')\nplt.rcParams[\"ytick.direction\"] = \"in\" # y軸の目盛線が内向き('in')か外向き('out')か双方向か('inout')\nplt.rcParams[\"xtick.major.width\"] = 1.0 # x軸主目盛り線の線幅\nplt.rcParams[\"ytick.major.width\"] = 1.0 # y軸主目盛り線の線幅\nplt.rcParams[\"font.size\"] = 12 # フォントの大きさ\nplt.rcParams[\"axes.linewidth\"] = 1.0 # 軸の線幅edge linewidth。囲みの太さ\nmatplotlib.font_manager._rebuild()\n\nMONO_DIR_PATH = \"../../Mono/\"\nAIRPLANE = ImageLoader(MONO_DIR_PATH + \"airplane512.bmp\")\nBARBARA = ImageLoader(MONO_DIR_PATH + \"barbara512.bmp\")\nBOAT = ImageLoader(MONO_DIR_PATH + \"boat512.bmp\")\nGOLDHILL = ImageLoader(MONO_DIR_PATH + \"goldhill512.bmp\")\nLENNA = ImageLoader(MONO_DIR_PATH + \"lenna512.bmp\")\nMANDRILL = ImageLoader(MONO_DIR_PATH + \"mandrill512.bmp\")\nMILKDROP = ImageLoader(MONO_DIR_PATH + \"milkdrop512.bmp\")\nSAILBOAT = ImageLoader(MONO_DIR_PATH + \"sailboat512.bmp\")", "_____no_output_____" ], [ "n_bar = 4\nN = 8", "_____no_output_____" ] ], [ [ "# MSDS", "_____no_output_____" ] ], [ [ "def msds(N,arr):\n w_e = 0\n e_e = 0\n n_e = 0\n s_e = 0\n nw_e = 0\n ne_e = 0\n sw_e = 0\n se_e = 0\n for row in range(arr.shape[0] // N):\n for col in range(arr.shape[1] // N):\n f_block = arr[row * N : (row + 1) * N, col * N : (col + 1) * N]\n # w\n if col == 0:\n w_block = np.fliplr(f_block)\n else:\n w_block = arr[row * N : (row + 1) * N, (col - 1) * N : col * N]\n # e\n if col == arr.shape[1] // N - 1:\n e_block = np.fliplr(f_block)\n else:\n e_block = arr[row * N : (row + 1) * N, (col + 1) * N : (col + 2) * N]\n # n\n if row == 0:\n n_block = np.flipud(f_block)\n else:\n n_block = arr[(row - 1) * N : row * N, col * N : (col + 1) * N]\n # s\n if row == arr.shape[0] // N - 1:\n s_block = np.flipud(f_block)\n else:\n s_block = arr[(row + 1) * N : (row + 2) * N, col * N : (col + 1) * N]\n\n w_d1 = f_block[:, 0] - w_block[:, N-1]\n e_d1 = f_block[:, N-1] - e_block[:, 0]\n n_d1 = f_block[0, :] - n_block[N-1, :]\n s_d1 = f_block[N-1, :] - s_block[0, :]\n\n w_d2 = (w_block[:, N-1] - w_block[:, N-2] + f_block[:, 1] - f_block[:, 0]) / 2\n e_d2 = (e_block[:, 1] - e_block[:, 0] + f_block[:, N-1] - f_block[:, N-2]) / 2\n n_d2 = (n_block[N-1, :] - n_block[N-2, :] + f_block[1, :] - f_block[0, :]) / 2\n s_d2 = (s_block[1, :] - s_block[0, :] + f_block[N-1, :] - f_block[N-2, :]) / 2\n\n w_e += np.sum((w_d1 - w_d2) ** 2 )\n e_e += np.sum((e_d1 - e_d2) ** 2 )\n n_e += np.sum((n_d1 - n_d2) ** 2)\n s_e += np.sum((s_d1 - s_d2) ** 2)\n\n # nw\n if row == 0 or col == 0:\n nw_block = np.flipud(np.fliplr(f_block))\n else:\n nw_block = arr[(row - 1) * N : row * N, (col - 1) * N : col * N]\n # ne\n if row == 0 or col == arr.shape[1] // N - 1:\n ne_block = np.flipud(np.fliplr(f_block))\n else:\n ne_block = arr[(row-1) * N : row * N, (col + 1) * N : (col + 2) * N]\n # sw\n if row == arr.shape[0] // N -1 or col == 0:\n sw_block = np.flipud(np.fliplr(f_block))\n else:\n sw_block = arr[row * N : (row+1) * N, (col-1) * N : col * N]\n # se\n if row == arr.shape[0]//N-1 or col == arr.shape[0] // N -1:\n se_block = np.flipud(np.fliplr(f_block))\n else:\n se_block = arr[(row + 1) * N : (row + 2) * N, (col+1) * N : (col + 2) * N]\n\n nw_g1 = f_block[0, 0] - nw_block[N-1, N-1]\n ne_g1 = f_block[0, N-1] - ne_block[N-1, 0]\n sw_g1 = f_block[N-1, 0] - sw_block[0, N-1]\n se_g1 = f_block[N-1, N-1] - se_block[0, 0]\n\n nw_g2 = (nw_block[N-1,N-1] - nw_block[N-2,N-2] + f_block[1,1] - f_block[0,0])/2\n ne_g2 = (ne_block[N-1,0] - ne_block[N-2,1] + f_block[1,N-2] - f_block[0,N-1])/2\n sw_g2 = (sw_block[0,N-1] - nw_block[1,N-2] + f_block[N-2,1] - f_block[N-1,0])/2\n se_g2 = (nw_block[0,0] - nw_block[1,1] + f_block[N-2,N-2] - f_block[N-1,N-1])/2\n\n nw_e += (nw_g1 - nw_g2) ** 2 \n ne_e += (ne_g1 - ne_g2) ** 2 \n sw_e += (sw_g1 - sw_g2) ** 2 \n se_e += (se_g1 - se_g2) ** 2 \n\n MSDSt = (w_e + e_e + n_e + s_e + nw_e + ne_e + sw_e + se_e)/ ((arr.shape[0]/N)**2)\n MSDS1 = (w_e + e_e + n_e + s_e)/ ((arr.shape[0]/N)**2)\n MSDS2 = (nw_e + ne_e + sw_e + se_e)/ ((arr.shape[0]/N)**2)\n return MSDSt, MSDS1, MSDS2", "_____no_output_____" ], [ "class DMLCT:\n def __init__(self, n_bar, N):\n self.n_bar = n_bar\n self.N = N\n\n self.x_l = (2 * np.arange(N) + 1) / (2 * N)\n self.s_l = np.arange(n_bar) / (n_bar - 1)\n self.xi = (np.arange(n_bar + 1) - 0.5) / (n_bar - 1)\n\n self.lambda_kh = self.get_lambda_kh(self.n_bar)\n\n self.w_k_j = self.get_w_k_j(self.n_bar, self.N)\n self.W_L_k_kh = self.get_W_L_k_kh(self.n_bar, self.N)\n self.W_k_kh = self.get_W_k_kh(self.n_bar, self.N)\n self.W_R_k_kh = self.get_W_R_k_kh(self.n_bar, self.N)\n\n def Lagrange_j(self, j):\n x = sympy.Symbol(\"x\")\n L_x = 1.0\n for l in range(self.n_bar):\n if l != j:\n L_x *= (x - self.s_l[l]) / (self.s_l[j] - self.s_l[l])\n return sympy.integrate(L_x)\n\n def get_lambda_kh(self, n_bar):\n lambda_kh = np.ones(n_bar)\n lambda_kh[0] = np.sqrt(1 / 2)\n return lambda_kh\n\n def get_w_k_j(self, n_bar, N):\n L_j = np.zeros((n_bar, N))\n x = sympy.Symbol(\"x\")\n for j in range(n_bar):\n temp = []\n Lj = self.Lagrange_j(j)\n for k in range(N):\n temp.append(Lj.subs(x, self.x_l[k]))\n L_j[j] = np.array(temp)\n\n w_k_j = np.zeros((n_bar, N))\n for j in range(n_bar):\n w_k_j[j] = scipy.fftpack.dct(L_j[j], norm=\"ortho\")\n return w_k_j\n\n def get_W_L_k_kh(self, n_bar, N):\n W_L_k_kh = np.zeros((n_bar - 1, N))\n lambda_kh = self.get_lambda_kh(n_bar)\n\n for kh in range(n_bar - 1):\n W_L_k_kh[kh] = (\n (1 - n_bar)\n * np.sqrt(2 / N)\n * lambda_kh[kh]\n * np.cos(np.pi * kh * (self.xi[0] + 1))\n * self.w_k_j[0]\n )\n return W_L_k_kh\n\n def get_W_k_kh(self, n_bar, N):\n W_k_kh = np.zeros((n_bar - 1, N))\n for kh in range(n_bar - 1):\n sum_sin = np.zeros(N)\n for j in range(1, n_bar - 2 + 1):\n sum_sin += np.sin(np.pi * kh * self.s_l[j]) * self.w_k_j[j]\n\n W_k_kh[kh] = (\n (n_bar - 1)\n * np.sqrt(2 / N)\n * self.lambda_kh[kh]\n * (\n np.cos(np.pi * kh * self.xi[1])\n * (self.w_k_j[0] - (-1) ** (kh) * self.w_k_j[n_bar - 1])\n - 2 * np.sin((np.pi * kh) / (2 * (n_bar - 1))) * sum_sin\n )\n )\n return W_k_kh\n\n def get_W_R_k_kh(self, n_bar, N):\n W_R_k_kh = np.zeros((n_bar - 1, N))\n for kh in range(n_bar - 1):\n W_R_k_kh[kh] = (\n (n_bar - 1)\n * np.sqrt(2 / N)\n * self.lambda_kh[kh]\n * np.cos(np.pi * kh * (self.xi[n_bar] - 1))\n * self.w_k_j[n_bar - 1]\n )\n return W_R_k_kh", "_____no_output_____" ], [ "def get_F_L_k_horizontal(arr, N, row, col):\n # w\n if col == 0:\n# w_block = np.zeros(N)\n w_block = arr[row, col * N : (col + 1) * N]\n else:\n w_block = arr[row, (col - 1) * N : col * N]\n\n return w_block", "_____no_output_____" ], [ "def get_F_R_k_horizontal(arr, N, row, col):\n # e\n if col == arr.shape[1] // N - 1:\n# e_block = np.zeros(N)\n e_block = arr[row, col * N : (col + 1) * N]\n else:\n e_block = arr[row, (col + 1) * N : (col + 2) * N]\n\n return e_block", "_____no_output_____" ], [ "def get_F_L_k_vertical(arr, N, row, col):\n # n\n if row == 0:\n# n_block = np.zeros(N)\n n_block = arr[row * N : (row + 1) * N, col]\n else:\n n_block = arr[(row - 1) * N : row * N, col]\n\n return n_block", "_____no_output_____" ], [ "def get_F_R_k_vertical(arr, N, row, col):\n # s\n if row == arr.shape[0] // N - 1:\n# s_block = np.zeros(N)\n s_block = arr[row * N : (row + 1) * N, col]\n else:\n s_block = arr[(row + 1) * N : (row + 2) * N, col]\n\n return s_block", "_____no_output_____" ], [ "# dmlct = DMLCT(n_bar, N)", "_____no_output_____" ], [ "IMG = AIRPLANE\n# IMG = ImageLoader(MONO_DIR_PATH + \"LENNA.bmp\")", "_____no_output_____" ], [ "Fk = np.zeros(IMG.img.shape)", "_____no_output_____" ] ], [ [ "# 順変換", "_____no_output_____" ], [ "## 縦方向", "_____no_output_____" ], [ "### DCT", "_____no_output_____" ] ], [ [ "for row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1]):\n eight_points = IMG.img[N * row : N * (row + 1), col]\n c = scipy.fftpack.dct(eight_points, norm=\"ortho\")\n Fk[N * row : N * (row + 1), col] = c", "_____no_output_____" ] ], [ [ "### 残差", "_____no_output_____" ] ], [ [ "dmlct = DMLCT(n_bar, N)\nfor row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1]):\n # ビューなら直接いじっちゃう\n F = Fk[N * row : N * (row + 1), col]\n F_L = get_F_L_k_vertical(Fk, N, row, col)\n F_R = get_F_R_k_vertical(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range(n_bar - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n # n_bar = 4 なら 0,1,2は残す 3,4,5,6,7を書き換える\n F[n_bar - 2 + 1 :] -= U_k_n_bar[n_bar - 2 + 1 :]", "_____no_output_____" ], [ "# 0を残す\nfor k in reversed(range(1, n_bar - 2 + 1)):\n dmlct = DMLCT(k+1, N)\n for row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1]):\n # ビューなら直接いじっちゃう\n F = Fk[N * row : N * (row + 1), col]\n F_L = get_F_L_k_vertical(Fk, N, row, col)\n F_R = get_F_R_k_vertical(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n\n for kh in range((k + 1) - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n F[k] -= U_k_n_bar[k]", "_____no_output_____" ] ], [ [ "## 横方向", "_____no_output_____" ], [ "### DCT", "_____no_output_____" ] ], [ [ "for row in range(Fk.shape[0]):\n for col in range(Fk.shape[1] // N):\n eight_points = Fk[row, N * col : N * (col + 1)]\n c = scipy.fftpack.dct(eight_points, norm=\"ortho\")\n Fk[row, N * col : N * (col + 1)] = c", "_____no_output_____" ] ], [ [ "### 残差", "_____no_output_____" ] ], [ [ "dmlct = DMLCT(n_bar, N)\nfor row in range(IMG.img.shape[0]):\n for col in range(IMG.img.shape[1] // N):\n F = Fk[row, N * col : N * (col + 1)]\n F_L = get_F_L_k_horizontal(Fk, N, row, col)\n F_R = get_F_R_k_horizontal(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range(n_bar - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n # n_bar = 4 なら 0,1,2は残す 3,4,5,6,7を書き換える\n F[n_bar - 2 + 1 :] -= U_k_n_bar[n_bar - 2 + 1 :]", "_____no_output_____" ], [ "# 0を残す\nfor k in reversed(range(1, n_bar - 2 + 1)):\n dmlct = DMLCT(k+1, N)\n for row in range(IMG.img.shape[0]):\n for col in range(IMG.img.shape[1] // N):\n F = Fk[row, N * col : N * (col + 1)]\n F_L = get_F_L_k_horizontal(Fk, N, row, col)\n F_R = get_F_R_k_horizontal(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n\n for kh in range((k + 1) - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n F[k] -= U_k_n_bar[k]", "_____no_output_____" ], [ "plt.imshow(Fk)\npd.DataFrame(Fk).to_csv(\"DMLCT_lenna_hiroya_coef.csv\",header=False,index=False)", "_____no_output_____" ] ], [ [ "# 係数の確保", "_____no_output_____" ] ], [ [ "Fk_Ori = np.copy(Fk)", "_____no_output_____" ] ], [ [ "# 逆変換", "_____no_output_____" ] ], [ [ "recover = np.zeros(IMG.img.shape)", "_____no_output_____" ] ], [ [ "## 横方向", "_____no_output_____" ], [ "### 残差", "_____no_output_____" ] ], [ [ "for k in range(1, n_bar - 2 + 1):\n dmlct = DMLCT(k+1, N)\n for row in range(IMG.img.shape[0]):\n for col in range(IMG.img.shape[1] // N):\n F = Fk[row, N * col : N * (col + 1)]\n F_L = get_F_L_k_horizontal(Fk, N, row, col)\n F_R = get_F_R_k_horizontal(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range((k + 1) - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n F[k] += U_k_n_bar[k]", "_____no_output_____" ], [ "dmlct = DMLCT(n_bar, N)\nfor row in range(IMG.img.shape[0]):\n for col in range(IMG.img.shape[1] // N):\n F = Fk[row, N * col : N * (col + 1)]\n F_L = get_F_L_k_horizontal(Fk, N, row, col)\n F_R = get_F_R_k_horizontal(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range(n_bar - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n # n_bar = 4 なら 0,1,2は残す 3,4,5,6,7を書き換える\n F[n_bar - 2 + 1 :] += U_k_n_bar[n_bar - 2 + 1 :]", "_____no_output_____" ] ], [ [ "### IDCT", "_____no_output_____" ] ], [ [ "for row in range(Fk.shape[0]):\n for col in range(Fk.shape[1] // N):\n F = Fk[row, N * col : N * col + N]\n data = scipy.fftpack.idct(F, norm=\"ortho\")\n # Fkに代入した後、縦方向に対して処理\n Fk[row, N * col : N * col + N] = data", "_____no_output_____" ] ], [ [ "## 縦方向", "_____no_output_____" ], [ "### 残差", "_____no_output_____" ] ], [ [ "for k in range(1, n_bar - 2 + 1):\n dmlct = DMLCT(k+1, N)\n for row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1]):\n # ビューなら直接いじっちゃう\n F = Fk[N * row : N * (row + 1), col]\n F_L = get_F_L_k_vertical(Fk, N, row, col)\n F_R = get_F_R_k_vertical(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n\n for kh in range((k + 1) - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n F[k] += U_k_n_bar[k]", "_____no_output_____" ], [ "dmlct = DMLCT(n_bar, N)\nfor row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1]):\n # ビューなら直接いじっちゃう\n F = Fk[N * row : N * (row + 1), col]\n F_L = get_F_L_k_vertical(Fk, N, row, col)\n F_R = get_F_R_k_vertical(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range(n_bar - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n # n_bar = 4 なら 0,1,2は残す 3,4,5,6,7を書き換える\n F[n_bar - 2 + 1 :] += U_k_n_bar[n_bar - 2 + 1 :]", "_____no_output_____" ] ], [ [ "### IDCT", "_____no_output_____" ] ], [ [ "for row in range(Fk.shape[0] // N):\n for col in range(Fk.shape[1]):\n F = Fk[N * row : N * (row + 1), col]\n data = scipy.fftpack.idct(F, norm=\"ortho\")\n # 復元画像\n recover[N * row : N * (row + 1), col] = data", "_____no_output_____" ], [ "plt.imshow(recover.astype(\"u8\"), cmap=\"gray\")", "_____no_output_____" ] ], [ [ "もどった...！", "_____no_output_____" ], [ "# 量子化テーブル", "_____no_output_____" ] ], [ [ "Q50_Luminance = np.array(\n [\n [16, 11, 10, 16, 24, 40, 51, 61],\n [12, 12, 14, 19, 26, 58, 60, 55],\n [14, 13, 16, 24, 40, 57, 69, 56],\n [14, 17, 22, 29, 51, 87, 80, 62],\n [18, 22, 37, 56, 68, 109, 103, 77],\n [24, 35, 55, 64, 81, 104, 113, 92],\n [49, 64, 78, 87, 103, 121, 120, 101],\n [72, 92, 95, 98, 112, 100, 103, 99],\n ]\n)", "_____no_output_____" ], [ "for i in tqdm_notebook(np.arange(1,10000,1)):\n Q = i / 100\n Q_Luminance = np.copy(Q50_Luminance)\n if Q < 50:\n Q_Luminance = Q_Luminance * 50 / Q\n Q_Luminance = np.where(Q_Luminance > 255, 255, Q_Luminance)\n else:\n Q_Luminance = (100 - Q) * Q50_Luminance / 50\n Q_Luminance = np.where(Q_Luminance < 1, 1, Q_Luminance)", "_____no_output_____" ] ], [ [ "# 量子化", "_____no_output_____" ] ], [ [ "Fk = np.copy(Fk_Ori)\nQ_Fk = np.zeros(Fk.shape)\nfor row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1] // N):\n block = Fk[row * N : (row + 1) * N, col * N : (col + 1) * N]\n # 量子化\n block = np.round(block / Q_Luminance)\n # 逆量子化\n block = block * Q_Luminance\n Q_Fk[row * N : (row+1)*N, col * N : (col+1)*N] = block", "_____no_output_____" ], [ "Fk = np.copy(Q_Fk)\nQ_recover = np.zeros(Q_Fk.shape)", "_____no_output_____" ] ], [ [ "## 横方向", "_____no_output_____" ], [ "### 残差", "_____no_output_____" ] ], [ [ "for k in range(1, n_bar - 2 + 1):\n dmlct = DMLCT(k+1, N)\n for row in range(IMG.img.shape[0]):\n for col in range(IMG.img.shape[1] // N):\n F = Fk[row, N * col : N * (col + 1)]\n F_L = get_F_L_k_horizontal(Fk, N, row, col)\n F_R = get_F_R_k_horizontal(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range((k + 1) - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n F[k] += U_k_n_bar[k]", "_____no_output_____" ], [ "dmlct = DMLCT(n_bar, N)\nfor row in range(IMG.img.shape[0]):\n for col in range(IMG.img.shape[1] // N):\n F = Fk[row, N * col : N * (col + 1)]\n F_L = get_F_L_k_horizontal(Fk, N, row, col)\n F_R = get_F_R_k_horizontal(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range(n_bar - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n # n_bar = 4 なら 0,1,2は残す 3,4,5,6,7を書き換える\n F[n_bar - 2 + 1 :] += U_k_n_bar[n_bar - 2 + 1 :]", "_____no_output_____" ] ], [ [ "### IDCT", "_____no_output_____" ] ], [ [ "for row in range(Fk.shape[0]):\n for col in range(Fk.shape[1] // N):\n F = Fk[row, N * col : N * col + N]\n data = scipy.fftpack.idct(F, norm=\"ortho\")\n # Fkに代入した後、縦方向に対して処理\n Fk[row, N * col : N * col + N] = data", "_____no_output_____" ] ], [ [ "## 縦方向", "_____no_output_____" ], [ "### 残差", "_____no_output_____" ] ], [ [ "for k in range(1, n_bar - 2 + 1):\n dmlct = DMLCT(k+1, N)\n for row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1]):\n # ビューなら直接いじっちゃう\n F = Fk[N * row : N * (row + 1), col]\n F_L = get_F_L_k_vertical(Fk, N, row, col)\n F_R = get_F_R_k_vertical(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n\n for kh in range((k + 1) - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n F[k] += U_k_n_bar[k]", "_____no_output_____" ], [ "dmlct = DMLCT(n_bar, N)\nfor row in range(IMG.img.shape[0] // N):\n for col in range(IMG.img.shape[1]):\n # ビューなら直接いじっちゃう\n F = Fk[N * row : N * (row + 1), col]\n F_L = get_F_L_k_vertical(Fk, N, row, col)\n F_R = get_F_R_k_vertical(Fk, N, row, col)\n\n U_k_n_bar = np.zeros(N)\n for kh in range(n_bar - 2 + 1):\n U_k_n_bar += (\n F_L[kh] * dmlct.W_L_k_kh[kh]\n + F[kh] * dmlct.W_k_kh[kh]\n + F_R[kh] * dmlct.W_R_k_kh[kh]\n )\n\n # n_bar = 4 なら 0,1,2は残す 3,4,5,6,7を書き換える\n F[n_bar - 2 + 1 :] += U_k_n_bar[n_bar - 2 + 1 :]", "_____no_output_____" ] ], [ [ "### IDCT", "_____no_output_____" ] ], [ [ "for row in range(Fk.shape[0] // N):\n for col in range(Fk.shape[1]):\n F = Fk[N * row : N * (row + 1), col]\n data = scipy.fftpack.idct(F, norm=\"ortho\")\n # 復元画像\n Q_recover[N * row : N * (row + 1), col] = data", "_____no_output_____" ], [ "Q_recover = np.round(Q_recover)", "_____no_output_____" ], [ "plt.imshow(Q_recover, cmap=\"gray\")\nplt.imsave(\"DMLCT_8x8_n\"+str(n_bar)+ \"_LENNA.png\",Q_recover,cmap=\"gray\")", "_____no_output_____" ] ], [ [ "# 情報量", "_____no_output_____" ] ], [ [ "qfk = pd.Series(Q_Fk.flatten())\npro = qfk.value_counts() / qfk.value_counts().sum()\npro.head()", "_____no_output_____" ], [ "S = 0\nfor pi in pro:\n S -= pi * np.log2(pi)\nS", "_____no_output_____" ] ], [ [ "# PSNR", "_____no_output_____" ] ], [ [ "MSE = np.sum(np.sum(np.power((IMG.img - Q_recover),2)))/(Q_recover.shape[0] * Q_recover.shape[1])\nPSNR = 10 * np.log10(255 * 255 / MSE)\nPSNR", "_____no_output_____" ] ], [ [ "# MSSIM", "_____no_output_____" ] ], [ [ "MSSIM = ssim(IMG.img,Q_recover.astype(IMG.img.dtype),gaussian_weights=True,sigma=1.5,K1=0.01,K2=0.03)\nMSSIM", "_____no_output_____" ], [ "dmlct = DMLCT(n_bar, N)", "_____no_output_____" ] ], [ [ "# MSDS", "_____no_output_____" ] ], [ [ "MSDSt, MSDS1, MSDS2 = msds(N,Q_recover)", "_____no_output_____" ], [ "MSDS1", "_____no_output_____" ], [ "MSDS2", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/Bluelord/DataCamp_Courses/blob/main/02%20Line%20charts.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ], [ "# Line Charts\n\n---\n\n\n\n---\n\n", "_____no_output_____" ], [ "## Tutorial\n\n---", "_____no_output_____" ] ], [ [ "# mounting drive\nfrom google.colab import drive\ndrive.mount(\"/content/drive\")", "Mounted at /content/drive\n" ], [ "# Importing libraries\nimport pandas as pd\npd.plotting.register_matplotlib_converters()\nimport matplotlib.pyplot as plt\n%matplotlib inline\nimport seaborn as sns", "_____no_output_____" ], [ "# Loading Data\nspotify_data = pd.read_csv(\"/content/drive/MyDrive/Colab Notebooks/Kaggle_Courses/03 Data Visualization/spotify.csv\",\n index_col=\"Date\", parse_dates=True)\nspotify_data", "_____no_output_____" ] ], [ [ "### Plot the data", "_____no_output_____" ] ], [ [ "# Sixe of plot\nplt.figure(figsize=(15,8))\n\n# Line chart showing daily global streams of each song \nsns.lineplot(data=spotify_data)", "_____no_output_____" ] ], [ [ "As you can see above, the line of code is relatively short and has two main components:\n- `sns.lineplot` tells the notebook that we want to create a line chart. \n - _Every command that you learn about in this course will start with `sns`, which indicates that the command comes from the [seaborn](https://seaborn.pydata.org/) package. For instance, we use `sns.lineplot` to make line charts. Soon, you'll learn that we use `sns.barplot` and `sns.heatmap` to make bar charts and heatmaps, respectively._\n- `data=spotify_data` selects the data that will be used to create the chart.\n\nNote that you will always use this same format when you create a line chart, and **_the only thing that changes with a new dataset is the name of the dataset_**. So, if you were working with a different dataset named `financial_data`, for instance, the line of code would appear as follows:\n```\nsns.lineplot(data=financial_data)\n```\n\nSometimes there are additional details we'd like to modify, like the size of the figure and the title of the chart. Each of these options can easily be set with a single line of code.", "_____no_output_____" ] ], [ [ "# Set the width and height of the figure\nplt.figure(figsize=(14,6))\n# Add title\nplt.title(\"Daily Global Streams of Popular Songs in 2017-2018\")\n# Line chart showing daily global streams of each song \nsns.lineplot(data=spotify_data)", "_____no_output_____" ] ], [ [ "The first line of code sets the size of the figure to `14` inches (in width) by `6` inches (in height). To set the size of _any figure_, you need only copy the same line of code as it appears. Then, if you'd like to use a custom size, change the provided values of `14` and `6` to the desired width and height.\nThe second line of code sets the title of the figure. Note that the title must *always* be enclosed in quotation marks (`\"...\"`)!\n\n", "_____no_output_____" ], [ "### Plot a subset of the data\n\nSo far, you've learned how to plot a line for _every_ column in the dataset. In this section, you'll learn how to plot a _subset_ of the columns.\n\nWe'll begin by printing the names of all columns. This is done with one line of code and can be adapted for any dataset by just swapping out the name of the dataset (in this case, `spotify_data`).", "_____no_output_____" ] ], [ [ "list(spotify_data.columns)", "_____no_output_____" ], [ "# Set the width and height of the figure\nplt.figure(figsize=(14,6))\n# Add title\nplt.title(\"Daily Global Streams of Popular Songs in 2017-2018\")\n\n# Line chart showing daily global streams of 'Shape of You'\nsns.lineplot(data=spotify_data['Shape of You'], label=\"Shape of You\")\n# Line chart showing daily global streams of 'Despacito'\nsns.lineplot(data=spotify_data['Despacito'], label=\"Despacito\")\n# Add label for horizontal axis\nplt.xlabel(\"Date\")", "_____no_output_____" ] ], [ [ "## Exercise \n\n---", "_____no_output_____" ] ], [ [ "data = pd.read_csv(\"/content/drive/MyDrive/Colab Notebooks/Kaggle_Courses/03 Data Visualization/museum_visitors.csv\",\n index_col=\"Date\", parse_dates=True)\n\n# Print the last five rows of the data \ndata.tail(5)", "_____no_output_____" ], [ "# How many visitors did the Chinese American Museum \n# receive in July 2018? \nca_museum_jul18 = 2620\n# In October 2018, how many more visitors did Avila \n# Adobe receive than the Firehouse Museum?\navila_oct18 = 19280-4622", "_____no_output_____" ], [ "# Line chart showing the number of visitors to each museum over time\nplt.figure(figsize = (12,5))\n# Title\nplt.title('Line chart showing the number of visitors')\nsns.lineplot(data=data)", "_____no_output_____" ], [ "# Line plot showing the number of visitors to Avila Adobe over time\nplt.figure(figsize = (12,5))\nsns.lineplot(data = data['Avila Adobe'])\nplt.title('number of visitors to Avila Adobe')\nplt.xlabel('Date')\nplt.ylabel('No. of Visitors')\nplt.show()", "_____no_output_____" ] ], [ [ "Does Avila Adobe get more visitors:\n\n* in September-February (in LA, the fall and winter months), OR\n* in March-August (in LA, the spring and summer)?\n\nThe line chart generally dips to relatively low values around the early part of each year in December and January, and reaches its highest values in the middle of the year, especially around May and June. Thus, Avila Adobe usually gets more visitors in March-August, Avila Adobe could definitely benefit from hiring more seasonal employees to help with the extra work in March-August.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Numpy template\n\n* Cells before the `# [[nbplot]] template` are ignored.\n* Cells starting with `# [[nbplot]] ignore` are also ignored.\n\n* Some variables are substituted in every cell:\n * `${root_path}`: the working directory when `nbplot` was called. Input files will be relative to this.\n\n* Some variables are subtituted in the `[[nbplot]] for i,input in enumerate(inputs)` blocks:\n * `${i}`: index of the input in the list\n * `${input.pretty_name}`: truncated path of the file, or 'stdin'\n * `${input.rel_path}`: path of the file relative to the `root_path`, or `stdin`\n * `${input.abs_path_or_io}`: full filepath or StringIO when the data comes from stdin\n * `${input.guessed_sep}`: separator guessed by nbplot for this file. Usually space or comma.", "_____no_output_____" ] ], [ [ "# [[nbplot]] template\n# Note: don't change that first line, it tells nbplot that the notebook below is a template\n# This cell will be executed and the metadata dictionary loaded, but not included in the output.\n\ntemplate_metadata = {\n 'name': 'numpy',\n 'format_version': '0.1'\n}", "_____no_output_____" ], [ "import io, math, os, sys\nfrom base64 import b64decode # for stdin\nfrom pathlib import Path\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport mplcursors # for interactive plot cursors\n\n# Transform x,y into a smooth x,y with splines (similar to gnuplot csplines)\n# Sample usage: ax.plot(*csplines(x,y)) # Don't forget the * to expand the output (x,y) tuple!\ndef csplines(x,y):\n from scipy.interpolate import make_interp_spline\n spl = make_interp_spline(x, y, 3)\n x_smooth = np.linspace(x[0], x[len(x)-1], max(300, len(x)*10)) # at least 10x the number of points\n return x_smooth, spl(x_smooth)\n\n# None will skip multiple spaces, ' ' will not.\ndef np_delim(delim): return None if delim == ' ' else delim", "_____no_output_____" ] ], [ [ "## <center> Cheatsheet gnuplot <> matplotlib </center>\n\n|Gnuplot | Matplotlib|\n| :-- | :-- |\n| `with lines` | `default` or `ax.plot(..., '-')` |\n| `with linespoints` | `ax.plot(..., '.-')` |\n| `with points` | `ax.plot(..., '.')` |\n| `smooth csplines` | `ax.plot(*csplines(x,y))` |\n| `using 1:2` | `ax.plot(data[:,0], data[:,1])` |\n| `using 0:1` | `ax.plot(data[:,0])` |", "_____no_output_____" ] ], [ [ "# interactive mode by default\n%matplotlib notebook\n#%matplotlib inline\nplt.ioff() # show the figure only at the end to avoid postponing potential loading errors\n\nfig,ax = plt.subplots(figsize=(8,6), num='MyWindow')\n#fig.suptitle('MyPlot')\n#ax.set_title('My Title')\n#ax.set_xlabel('x')\n#ax.set_ylabel('y')\n\nroot_path = Path(\"$root_path\")\n\n# [[nbplot]] for i,input in enumerate(inputs)\nname${i} = \"${input.pretty_name}\"; file_or_io${i} = ${input.abs_path_or_io}\ndata${i} = np.genfromtxt(file_or_io${i}, dtype=float, comments='#', delimiter=np_delim('${input.guessed_sep}'), skip_header=0)\ndisplay(data0[:4])\nx, y = (data${i}[:,0], data${i}[:,1]) if data${i}.ndim > 1 else (np.arange(0,data${i}.shape[0]), data${i})\nax.plot(x, y, label=name${i})\n# [[nbplot]] endfor\n\nax.legend()\nmplcursors.cursor() # enable the cursors, left click to annotate a point, right click to hide it.\nplt.show() # show the plot\nplt.ion(); # restore interactive mode", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "## Missing Category Imputation ==> Feature-Engine\n\n\n### What is Feature-Engine\n\nFeature-Engine is an open source python package that I created at the back of this course. \n\n- Feature-Engine includes all the feature engineering techniques described in the course\n- Feature-Engine works like to Scikit-learn, so it is easy to learn\n- Feature-Engine allows you to implement specific engineering steps to specific feature subsets\n- Feature-Engine can be integrated with the Scikit-learn pipeline allowing for smooth model building\n- \n**Feature-Engine allows you to design and store a feature engineering pipeline with bespoke procedures for different variable groups.**\n\n-------------------------------------------------------------------\nFeature-Engine can be installed via pip ==> pip install feature-engine\n\n- Make sure you have installed feature-engine before running this notebook\n\nFor more information visit:\nmy website\n\n## In this demo\n\nWe will use Feature-Engine to perform mean or median imputation using the Ames House Price Dataset.\n\n- To download the dataset visit the lecture **Datasets** in **Section 1** of the course.", "_____no_output_____" ] ], [ [ "import pandas as pd\nimport numpy as np\n\nimport matplotlib.pyplot as plt\n\n# to split the datasets\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.pipeline import Pipeline\n\n# from feature-engine\nfrom feature_engine.imputation import CategoricalImputer", "_____no_output_____" ], [ "# let's load the dataset with a selected group of variables\n\ncols_to_use = [\n 'BsmtQual', 'FireplaceQu', 'LotFrontage', 'MasVnrArea', 'GarageYrBlt',\n 'SalePrice'\n]\n\ndata = pd.read_csv('../houseprice.csv', usecols=cols_to_use)\ndata.head()", "_____no_output_____" ], [ "data.isnull().mean()", "_____no_output_____" ], [ "# let's separate into training and testing set\n\n# first drop the target from the feature list\ncols_to_use.remove('SalePrice')\n\nX_train, X_test, y_train, y_test = train_test_split(data[cols_to_use],\n data['SalePrice'],\n test_size=0.3,\n random_state=0)\nX_train.shape, X_test.shape", "_____no_output_____" ] ], [ [ "### Feature-Engine captures the categorical variables automatically", "_____no_output_____" ] ], [ [ "# we call the imputer from featur- engine\n# we don't need to specify anything \n\nimputer = CategoricalImputer()", "_____no_output_____" ], [ "# we fit the imputer\n\nimputer.fit(X_train)", "_____no_output_____" ], [ "# we see that the imputer found the categorical variables to\n# impute with the frequent category\n\nimputer.variables", "_____no_output_____" ] ], [ [ "**This imputer will replace missing data in categorical variables by 'Missing'**", "_____no_output_____" ] ], [ [ "# feature-engine returns a dataframe\n\ntmp = imputer.transform(X_train)\ntmp.head()", "_____no_output_____" ], [ "# let's check that the numerical variables don't\n# contain NA any more\n\ntmp[imputer.variables].isnull().mean()", "_____no_output_____" ] ], [ [ "## Feature-engine allows you to specify variable groups easily", "_____no_output_____" ] ], [ [ "# let's do it imputation but this time\n# and let's do it over 1 of the 2 categorical variables\n\nimputer = CategoricalImputer(variables=['BsmtQual'])\n\nimputer.fit(X_train)", "_____no_output_____" ], [ "# now the imputer uses only the variables we indicated\n\nimputer.variables", "_____no_output_____" ], [ "# transform data set\n\ntmp = imputer.transform(X_train)\ntmp.head()", "_____no_output_____" ], [ "tmp[imputer.variables].isnull().mean()", "_____no_output_____" ] ], [ [ "## Feature-engine can be used with the Scikit-learn pipeline", "_____no_output_____" ] ], [ [ "# let's check the percentage of NA in each categorical variable\n\nX_train.isnull().mean()", "_____no_output_____" ] ], [ [ "- BsmtQual: 0.023 ==> frequent category imputation\n- FirePlaceQu: 0.46 ==> missing category imputation", "_____no_output_____" ] ], [ [ "pipe = Pipeline([\n ('imputer_mode', CategoricalImputer(imputation_method='frequent', variables=['BsmtQual'])),\n ('imputer_missing', CategoricalImputer(variables=['FireplaceQu'])),\n])", "_____no_output_____" ], [ "pipe.fit(X_train)", "_____no_output_____" ], [ "pipe.named_steps['imputer_mode'].variables", "_____no_output_____" ], [ "pipe.named_steps['imputer_missing'].variables", "_____no_output_____" ], [ "# let's transform the data with the pipeline\ntmp = pipe.transform(X_train)\n\n# let's check null values are gone\ntmp.isnull().mean()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Now You Code 1: Number\n\nIn this now you code we will learn to re-factor a program into a function. This is the most common way to write a function when you are a beginner. *Re-factoring* is the act of re-writing code without changing its functionality. We commonly do re-factoring to improve performance or readability of our code.\n\nThe way you do this is rather simple. First you write a program to solve the problem, then you re-write that program as a function and finally test the function to make sure it works as expected. \n\nThis helps train you to think abstractly about problems, but leverages what you understand currently about programming.\n\n## First we write the program \n\nWrite a program to take an input string and convert to a float. If the string cannot be converted to a float it returns the string \"NaN\" which means \"Not a Number\" We did this first part for you.\n\n## Step 1: Problem Analysis\n\nInputs: Any value\n\nOutputs: whether that value is a number\n\nAlgorithm:\n\n1. input a value\n2. try to convert the value to a number\n3. if you can convert it, print the number\n4. if you cannot print 'NaN' for Not a number.", "_____no_output_____" ] ], [ [ "## STEP 2 : Write the program\ntext = input(\"Enter a number: \")\ntry:\n number = float(text)\nexcept ValueError:\n number = \"NaN\"\n \nprint(number)", "Enter a number: 5\n5.0\n" ] ], [ [ "## Next we refactor it into a function\n\nComplete this function. It should be similar to the program above, but it should not have any `input()` or `print()` functions as those are reserved for the main program. Functions should take variables as input and return a variable as output. When the function executes, the variables are replaced with actual values. Our function in question takes `text` as input and returns `number` as output.\n", "_____no_output_____" ] ], [ [ "# Step 3: write the function\n## Function: Number\n## Argument (input): text value\n## Returns (output): float of text value or \"NaN\"\n\ndef number(text):\n # TODO Write code here\n ", "_____no_output_____" ] ], [ [ "## Rewrite the program to use the function\n\nFinally re-write the original program to use the new function. The program now works the same as STEP1 but it now uses a function!", "_____no_output_____" ] ], [ [ "## Step 4: write the program from step 2 again, but this time use the function\n\n", "_____no_output_____" ] ], [ [ "## Step 3: Questions\n\n1. Can you define a function with the same name more than once?\n2. Can you call a function with the name name more than once?\n3. What is the input to the number function? What is the output?\n", "_____no_output_____" ], [ "## Reminder of Evaluation Criteria\n\n1. What the problem attempted (analysis, code, and answered questions) ?\n2. What the problem analysis thought out? (does the program match the plan?)\n3. Does the code execute without syntax error?\n4. Does the code solve the intended problem?\n5. Is the code well written? (easy to understand, modular, and self-documenting, handles errors)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# SelfBuildingModel\n[www.vexpower.com](www.vexpower.com)", "_____no_output_____" ] ], [ [ "# Set the right folder\n\nimport sys\nimport os\n\nif not os.path.isdir(\"mmm\"):\n module_path = os.path.abspath(os.path.join('..'))\n if module_path not in sys.path:\n sys.path.append(module_path)\n\nimport mmm", "_____no_output_____" ], [ "import pandas as pd\npd.set_option('display.float_format', lambda x: '%.3f' % x) # suppress scientific notation\n\n# Load dataset\n\nfile_name = \"GoolyBib-ABT - Sheet1.csv\"\ndata = pd.read_csv('../data/'+file_name)\ndata.head()", "_____no_output_____" ], [ "from IPython.display import display\n\nfrom mmm.clean import make_column_index\nfrom mmm.engineer import add_constant\nfrom mmm.select import get_all_X_labels, guess_date_column, guess_y_column, guess_media_columns, backwards_feature_elimination, find_best_feature \nfrom mmm.build import run_regression, create_results_df, create_pred_df\nfrom mmm.validate import calculate_r2\nfrom mmm.display import display_accuracy_chart, save_model, display_contrib_chart, display_decomp_chart\n\n\nclass SelfBuildingModel():\n def __init__(self, file_name):\n # load data\n self.df = pd.read_csv('../data/'+file_name)\n \n # Guess labels\n self.date_label = guess_date_column(self.df)\n make_column_index(self.df, self.date_label)\n add_constant(self.df)\n self.y_label = guess_y_column(self.df)\n self.X_labels = get_all_X_labels(self.df, self.y_label)\n self.media_labels = guess_media_columns(self.df)\n self.base_labels = [l for l in self.X_labels if l not in self.media_labels]\n \n # Set placeholders\n self.coefficients = None\n self.p_values = None\n self.error_label = \"R2\"\n self.error_func = calculate_r2\n self.error_value = None\n self.y_actual = None\n self.y_pred = None\n self.pred_df = None \n \n # Self-build model\n self._ffs()\n \n def _ffs(self):\n self.find()\n y_label, error_value, X_labels, coefficients = self.fit()\n save_model(y_label, error_value, X_labels, coefficients)\n self.show()\n \n def find(self):\n # bfe on base variables\n base_keep = backwards_feature_elimination(self.df, self.y_label, self.base_labels)\n \n # find best adstock and diminishing return rate of each media variable\n best_media_labels = []\n for m in self.media_variables:\n adstock_columns = add_adstocks(self.df, m)\n best_adstock_column = find_best_feature(self.df, self.y_label, adstock_columns, base_keep)\n \n diminishing_columns = add_diminishing_returns(self.df, best_adstock_column)\n \n best_diminishing_column = find_best_feature(self.df, self.y_label, diminishing_columns, base_keep)\n best_media_labels.append(best_diminishing_column)\n \n self.best_X_labels = base_keep + best_media_labels\n \n def fit(self):\n y_actual, y_pred, coefficients, p_values = run_regression(self.df, self.y_label, self.best_X_labels)\n self.y_actual, self.y_pred, self.coefficients, self.p_values = y_actual, y_pred, coefficients, p_values\n \n self.error_value = self.error_func(self.y_actual, self.y_pred)\n \n self.results_df = create_results_df(self.X_labels, self.coefficients, self.p_values)\n \n self.pred_df = create_pred_df(self.df, self.results_df)\n \n return self.y_label, self.error_value, self.X_labels, self.coefficients\n \n def show(self):\n display(self.results_df)\n\n display_accuracy_chart(self.y_actual, self.y_pred, self.y_label, \n accuracy=(self.error_label, self.error_value))\n \n display_contrib_chart(self.pred_df)\n display_decomp_chart(self.pred_df)", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# pytorch-yolo2", "_____no_output_____" ], [ "ref: https://github.com/longcw/yolo2-pytorch", "_____no_output_____" ], [ "### get model", "_____no_output_____" ] ], [ [ "from darknet import Darknet", "_____no_output_____" ], [ "cfgfile = './cfg/yolo-pose.cfg' \nweightfile = './backup/cargo/model_backup.weights'\nweightfile2 = './backup/cargo/model.weights'", "_____no_output_____" ], [ "m = Darknet(cfgfile)\nm2 = Darknet(cfgfile)\nm.load_weights(weightfile)\nm2.load_weights(weightfile2)\nprint('Loading weights from %s... Done!' % (weightfile))\nprint('Loading weights from %s... Done!' % (weightfile2))", "_____no_output_____" ] ], [ [ "### save detection information", "_____no_output_____" ] ], [ [ "import pickle\nop_dict = {\n 'num_classes':m.num_classes,\n 'anchors':m.anchors,\n 'num_anchors':m.num_anchors\n}\npickle.dump(op_dict, open('detection_information.pkl','wb'))", "_____no_output_____" ] ], [ [ "# use Onnx to convert model", "_____no_output_____" ], [ "ref: https://github.com/onnx/tutorials/blob/master/tutorials/PytorchOnnxExport.ipynb", "_____no_output_____" ] ], [ [ "import torch.onnx\nfrom torch.autograd import Variable\n\n# Standard ImageNet input - 3 channels, 224x224,\n# values don't matter as we care about network structure.\n# But they can also be real inputs.\ndummy_input = Variable(torch.randn(1, 3, 416, 416))\n# Obtain your model, it can be also constructed in your script explicitly\nmodel = m\nmodel2 = m2\n# Invoke export\ntorch.onnx.export(model, dummy_input, \"cargo_yolo2.onnx\")\ntorch.onnx.export(model2, dummy_input, \"cargo_yolo2_v2.onnx\")", "_____no_output_____" ] ], [ [ "# Build TensorRT engine and serialize it", "_____no_output_____" ] ], [ [ "import cv2\nimport numpy as np\nfrom numpy import array\n\nimport pycuda.driver as cuda\nimport pycuda.autoinit\n\nimport tensorrt as trt\n\nimport sys, os\nsys.path.insert(1, os.path.join(sys.path[0], \"..\"))\nimport common\n\n# You can set the logger severity higher to suppress messages (or lower to display more messages).\nTRT_LOGGER = trt.Logger(trt.Logger.WARNING)", "_____no_output_____" ], [ "import matplotlib\nimport matplotlib.pyplot as plt\n%matplotlib inline", "_____no_output_____" ], [ "def get_engine(onnx_file_path, engine_file_path=\"\"):\n \"\"\"Attempts to load a serialized engine if available, otherwise builds a new TensorRT engine and saves it.\"\"\"\n def build_engine():\n \"\"\"Takes an ONNX file and creates a TensorRT engine to run inference with\"\"\"\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:\n builder.max_workspace_size = 1 << 30 # 1GB\n builder.max_batch_size = 1\n # Parse model file\n if not os.path.exists(onnx_file_path):\n print('ONNX file {} not found, please run yolov3_to_onnx.py first to generate it.'.format(onnx_file_path))\n exit(0)\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\n with open(onnx_file_path, 'rb') as model:\n print('Beginning ONNX file parsing')\n parser.parse(model.read())\n print('Completed parsing of ONNX file')\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\n engine = builder.build_cuda_engine(network)\n print(\"Completed creating Engine\")\n with open(engine_file_path, \"wb\") as f:\n f.write(engine.serialize())\n return engine\n\n if os.path.exists(engine_file_path):\n # If a serialized engine exists, use it instead of building an engine.\n print(\"Reading engine from file {}\".format(engine_file_path))\n with open(engine_file_path, \"rb\") as f, trt.Runtime(TRT_LOGGER) as runtime:\n return runtime.deserialize_cuda_engine(f.read())\n else:\n return build_engine()", "_____no_output_____" ], [ "# Try to load a previously generated yolo network graph in ONNX format:\nonnx_file_path = './cargo_yolo2.onnx'\nonnx_file_v2_path = './cargo_yolo2_v2.onnx'\nengine_file_path = './cargo_yolo2.trt'\nengine_file_v2_path = './cargo_yolo2_v2.trt'\ninput_image_path = './cargo_sample.jpg'", "_____no_output_____" ], [ "def preprosess_img(img_path):\n frame = cv2.imread(img_path,0)\n img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n yolo_img =cv2.resize(img, (416, 416), interpolation=cv2.INTER_AREA)\n plt.imshow(img)\n return yolo_img", "_____no_output_____" ], [ "# Do inference with TensorRT\ntrt_outputs = []\nwith get_engine(onnx_file_v2_path, engine_file_v2_path) as engine, engine.create_execution_context() as context:\n inputs, outputs, bindings, stream = common.allocate_buffers(engine)\n print(type(engine))\n img = preprosess_img(input_image_path)\n # Do inference\n print('Running inference on image {}...'.format(input_image_path))\n # Set host input to the image. The common.do_inference function will copy the input to the GPU before executing.\n inputs[0].host = img\n trt_outputs = common.do_inference(context, bindings=bindings, inputs=inputs, outputs=outputs, stream=stream)\n print(trt_outputs)\n print(type(trt_outputs))", "Reading engine from file ./cargo_yolo2_v2.trt\n<class 'tensorrt.tensorrt.ICudaEngine'>\nRunning inference on image ./cargo_sample.jpg...\n[array([ -inf, -inf, -inf, ..., -250.57047 ,\n -136.78687 , -2.5162568], dtype=float32)]\n<class 'list'>\n" ], [ "plt.imshow(img)", "_____no_output_____" ], [ "output_shapes = [(1,20,13,13)]\n#trt_outputs = [output.reshape(shape) for output, shape in zip(trt_outputs, output_shapes)]\ntrt_outputs = array(trt_outputs).reshape(1,20,13,13)\n# print('trt_outputs type', type(trt_outputs))", "_____no_output_____" ], [ "print('trt outputs shape ', trt_outputs.shape)", "trt outputs shape (1, 20, 13, 13)\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "CC0-1.0" ]

[ "CC0-1.0" ]

[ "CC0-1.0" ]

[ [ [ "import matplotlib.pyplot as plt\nimport numpy as np\n%matplotlib inline", "_____no_output_____" ] ], [ [ "## Automatic Feature Selection\nOften we collected many features that might be related to a supervised prediction task, but we don't know which of them are actually predictive. To improve interpretability, and sometimes also generalization performance, we can use automatic feature selection to select a subset of the original features. There are several types of feature selection methods available, which we'll explain in order of increasing complexity.\n\nFor a given supervised model, the best feature selection strategy would be to try out each possible subset of the features, and evaluate generalization performance using this subset. However, there are exponentially many subsets of features, so this exhaustive search is generally infeasible. The strategies discussed below can be thought of as proxies for this infeasible computation.\n\n### Univariate statistics\nThe simplest method to select features is using univariate statistics, that is by looking at each feature individually and running a statistical test to see whether it is related to the target. This kind of test is also known as analysis of variance (ANOVA).\n\nWe create a synthetic dataset that consists of the breast cancer data, with an addition of 50 completely random features.", "_____no_output_____" ] ], [ [ "from sklearn.datasets import load_breast_cancer, load_digits\nfrom sklearn.model_selection import train_test_split\n\ncancer = load_breast_cancer()\n\n# get deterministic random numbers\nrng = np.random.RandomState(42)\nnoise = rng.normal(size=(len(cancer.data), 50))\n# add noise features to the data\n# the first 30 features are from the dataset, the next 50 are noise\nX_w_noise = np.hstack([cancer.data, noise])\n\nX_train, X_test, y_train, y_test = train_test_split(\n X_w_noise, cancer.target, random_state=0, test_size=.5)\n", "_____no_output_____" ] ], [ [ "We have to define a threshold on the p-value of the statistical test to decide how many features to keep. There are several strategies implemented in scikit-learn, a straight-forward one being ``SelectPercentile``, which selects a percentile of the original features (we select 50% below):", "_____no_output_____" ] ], [ [ "from sklearn.feature_selection import SelectPercentile\n\n# use f_classif (the default) and SelectPercentile to select 50% of features:\nselect = SelectPercentile(percentile=50)\nselect.fit(X_train, y_train)\n# transform training set:\nX_train_selected = select.transform(X_train)\n\nprint(X_train.shape)\nprint(X_train_selected.shape)", "_____no_output_____" ] ], [ [ "We can also use the test statistic directly to see how relevant each feature is. As the breast cancer dataset is a classification task, we use f_classif, the F-test for classification. Below we plot the p-values associated with each of the 80 features (30 original features + 50 noise features). Low p-values indicate informative features.", "_____no_output_____" ] ], [ [ "from sklearn.feature_selection import f_classif, f_regression, chi2", "_____no_output_____" ], [ "F, p = f_classif(X_train, y_train)", "_____no_output_____" ], [ "plt.figure()\nplt.plot(p, 'o')", "_____no_output_____" ] ], [ [ "Clearly most of the first 30 features have very small p-values.\n\nGoing back to the SelectPercentile transformer, we can obtain the features that are selected using the ``get_support`` method:", "_____no_output_____" ] ], [ [ "mask = select.get_support()\nprint(mask)\n# visualize the mask. black is True, white is False\nplt.matshow(mask.reshape(1, -1), cmap='gray_r')", "_____no_output_____" ] ], [ [ "Nearly all of the original 30 features were recovered.\nWe can also analize the utility of the feature selection by training a supervised model on the data.\nIt's important to learn the feature selection only on the training set!", "_____no_output_____" ] ], [ [ "from sklearn.linear_model import LogisticRegression\n\n# transform test data:\nX_test_selected = select.transform(X_test)\n\nlr = LogisticRegression()\nlr.fit(X_train, y_train)\nprint(\"Score with all features: %f\" % lr.score(X_test, y_test))\nlr.fit(X_train_selected, y_train)\nprint(\"Score with only selected features: %f\" % lr.score(X_test_selected, y_test))", "_____no_output_____" ] ], [ [ "### Model-based Feature Selection\nA somewhat more sophisticated method for feature selection is using a supervised machine learning model, and selecting features based on how important they were deemed by the model. This requires the model to provide some way to rank the features by importance. This can be done for all tree-based models (which implement ``get_feature_importances``) and all linear models, for which the coefficients can be used to determine how much influence a feature has on the outcome.\n\nAny of these models can be made into a transformer that does feature selection by wrapping it with the ``SelectFromModel`` class:", "_____no_output_____" ] ], [ [ "from sklearn.feature_selection import SelectFromModel\nfrom sklearn.ensemble import RandomForestClassifier\nselect = SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold=\"median\")", "_____no_output_____" ], [ "select.fit(X_train, y_train)\nX_train_rf = select.transform(X_train)\nprint(X_train.shape)\nprint(X_train_rf.shape)", "_____no_output_____" ], [ "mask = select.get_support()\n# visualize the mask. black is True, white is False\nplt.matshow(mask.reshape(1, -1), cmap='gray_r')", "_____no_output_____" ], [ "X_test_rf = select.transform(X_test)\nLogisticRegression().fit(X_train_rf, y_train).score(X_test_rf, y_test)", "_____no_output_____" ] ], [ [ "This method builds a single model (in this case a random forest) and uses the feature importances from this model.\nWe can do a somewhat more elaborate search by training multiple models on subsets of the data. One particular strategy is recursive feature elimination:", "_____no_output_____" ], [ "### Recursive Feature Elimination\nRecursive feature elimination builds a model on the full set of features, and similar to the method above selects a subset of features that are deemed most important by the model. However, usually only a single feature is dropped from the dataset, and a new model is build on the remaining features. The process of dropping features and model building is repeated until there are only a pre-specified number of features left:", "_____no_output_____" ] ], [ [ "from sklearn.feature_selection import RFE\nselect = RFE(RandomForestClassifier(n_estimators=100, random_state=42), n_features_to_select=40)\n\nselect.fit(X_train, y_train)\n# visualize the selected features:\nmask = select.get_support()\nplt.matshow(mask.reshape(1, -1), cmap='gray_r')", "_____no_output_____" ], [ "X_train_rfe = select.transform(X_train)\nX_test_rfe = select.transform(X_test)\n\nLogisticRegression().fit(X_train_rfe, y_train).score(X_test_rfe, y_test)", "_____no_output_____" ], [ "select.score(X_test, y_test)", "_____no_output_____" ] ], [ [ "# Exercises", "_____no_output_____" ], [ "Plot the \"XOR\" dataset which is created like this:", "_____no_output_____" ] ], [ [ "xx, yy = np.meshgrid(np.linspace(-3, 3, 50),\n np.linspace(-3, 3, 50))\nrng = np.random.RandomState(0)\nX = rng.randn(200, 2)\nY = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0)", "_____no_output_____" ] ], [ [ "Add random features to it and compare how univariate selection compares to model based selection using a Random Forest in recovering the original features.", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import spacy\nimport pickle\nimport random", "_____no_output_____" ], [ "train_data = pickle.load(open('train_data.pkl', 'rb'))\ntrain_data[0]", "_____no_output_____" ], [ "nlp = spacy.blank('en')\n\ndef train_model(train_data):\n if 'ner' not in nlp.pipe_names:\n ner = nlp.create_pipe('ner')\n nlp.add_pipe(ner, last = True)\n \n for _, annotation in train_data:\n for ent in annotation['entities']:\n ner.add_label(ent[2])\n \n \n other_pipes = [pipe for pipe in nlp.pipe_names if pipe != 'ner']\n with nlp.disable_pipes(*other_pipes): # only train NER\n optimizer = nlp.begin_training()\n for itn in range(100):\n print(\"Statring iteration \" + str(itn))\n random.shuffle(train_data)\n losses = {}\n index = 0\n for text, annotations in train_data:\n try:\n nlp.update(\n [text], # batch of texts\n [annotations], # batch of annotations\n drop=0.2, # dropout - make it harder to memorise data\n sgd=optimizer, # callable to update weights\n losses=losses)\n except Exception as e:\n pass\n \n print(losses)\n \n ", "_____no_output_____" ], [ "train_model(train_data)", "D:\\Users\\USER\\Anaconda3\\lib\\site-packages\\spacy\\language.py:639: UserWarning: [W033] Training a new parser or NER using a model with no lexeme normalization table. This may degrade the performance of the model to some degree. If this is intentional or the language you're using doesn't have a normalization table, please ignore this warning. If this is surprising, make sure you have the spacy-lookups-data package installed. The languages with lexeme normalization tables are currently: da, de, el, en, id, lb, pt, ru, sr, ta, th.\n **kwargs\n" ], [ "import fitz\ndoc = fitz.open(r'D:/Documents/GSoC/resumes/dhmkrwtksdgy.pdf')\ntext = \"\"\n\nfor page in doc:\n text = text + str(page.getText())\n\ntxt = \" \".join(text.split(\"\\n\"))\ntype(txt)", "_____no_output_____" ], [ "nlp.to_disk('resume_sum1')", "_____no_output_____" ], [ "!pwd", "/d/Documents/My_projects\n" ], [ "model = spacy.load('resume_sum1')", "_____no_output_____" ], [ "doc = model(txt)\nfor ent in doc.ents:\n print(ent.label_.upper(), ent.text)", "NAME Anubhav Singh\nCOLLEGE NAME Subhash Engineering College Kolkata\nCOMPANIES WORKED AT Information Technology\nLOCATION Machine\nSKILLS Languages: Python, PHP, C++, JavaScript, SQL, Bash, JAVA • Frameworks: Scikit, NLTK, SpaCy, TensorFlow, Keras, Django, Flask, NodeJS, LAMP • Tools: Kubernetes, Docker, GIT, PostgreSQL, MySQL, SQLite • Platforms: Linux, Web, Windows, Arduino, Raspberry, AWS, GCP, Alibaba Cloud, IBM Cloud • Soft Skills: Leadership, Event Management, Writing, Public Speaking, Time Management Experience • Google Summer of Code - Submitty Remote Student Developer (Full-time) May 2019 - Sep 2019 ◦ Discussion Forum Upgrades: Refactor forum for performance to handle large databases. ◦ REST\nGRADUATION YEAR 2018\nLOCATION Kolkata\n" ], [ "doc.ents", "_____no_output_____" ], [ "doc.ents[1]", "_____no_output_____" ], [ "print(\"ent.label_.upper()\" + \" ent.text\")", "ent.label_.upper() ent.text\n" ], [ "type(doc.ents)", "_____no_output_____" ], [ "cv1 = \"Alice Clark AI / Machine Learning Delhi, India Email me on Indeed • 20+ years of experience in data handling, design, and development • Data Warehouse: Data analysis, star/snow flake scema data modelling and design specific to data warehousing and business intelligence • Database: Experience in database designing, scalability, back-up and recovery, writing and optimizing SQL code and Stored Procedures, creating functions, views, triggers and indexes. Cloud platform: Worked on Microsoft Azure cloud services like Document DB, SQL Azure, Stream Analytics, Event hub, Power BI, Web Job, Web App, Power BI, Azure data lake analytics(U-SQL) Willing to relocate anywhere WORK EXPERIENCE Software Engineer Microsoft – Bangalore, Karnataka January 2000 to Present 1. Microsoft Rewards Live dashboards: Description: - Microsoft rewards is loyalty program that rewards Users for browsing and shopping online. Microsoft Rewards members can earn points when searching with Bing, browsing with Microsoft Edge and making purchases at the Xbox Store, the Windows Store and the Microsoft Store. Plus, user can pick up bonus points for taking daily quizzes and tours on the Microsoft rewards website. Rewards live dashboards gives a live picture of usage world-wide and by markets like US, Canada, Australia, new user registration count, top/bottom performing rewards offers, orders stats and weekly trends of user activities, orders and new user registrations. the PBI tiles gets refreshed in different frequencies starting from 5 seconds to 30 minutes. Technology/Tools used EDUCATION Indian Institute of Technology – Mumbai 2001 SKILLS Machine Learning, Natural Language Processing, and Big Data Handling ADDITIONAL INFORMATION Professional Skills • Excellent analytical, problem solving, communication, knowledge transfer and interpersonal skills with ability to interact with individuals at all the levels • Quick learner and maintains cordial relationship with project manager and team members and good performer both in team and independent job environments • Positive attitude towards superiors &amp; peers • Supervised junior developers throughout project lifecycle and provided technical assistance \"", "_____no_output_____" ], [ "doc = model(cv1)\nfor ent in doc.ents:\n print(f'{ent.label_.upper():{30}}- {ent.text}')", "NAME - Alice Clark \nCOMPANIES WORKED AT - Microsoft\nDESIGNATION - Software Engineer\nCOMPANIES WORKED AT - Microsoft\nCOMPANIES WORKED AT - Microsoft\nCOMPANIES WORKED AT - Microsoft\nCOMPANIES WORKED AT - Microsoft\nDEGREE - Indian Institute of Technology – Mumbai\nSKILLS - Machine Learning, Natural Language Processing, and Big Data Handling ADDITIONAL INFORMATION\n" ], [ "a", "_____no_output_____" ], [ "import re\nimport spacy\nimport os\nfrom flask import Flask, request, redirect, url_for, render_template, send_from_directory\nimport fitz\nfrom werkzeug.utils import secure_filename\nimport pickle\nimport nltk \nimport numpy as np #for large and multi-dimensional arrays\nimport pandas as pd\nfrom nltk.corpus import stopwords\nfrom sklearn.ensemble import RandomForestClassifier\nfrom nltk.stem.porter import PorterStemmer\nfrom sklearn.feature_extraction.text import TfidfVectorizer \nimport pdb\n\n#r'D:/Documents/GSoC/resumes/dhmkrwtksdgy.pdf'\npath = r'D:/Documents/GSoC/resumes'\nfilename = 'dhmkrwtksdgy.pdf'\n\n\n\ndef red_pdf(path,filename):\n doc = fitz.open((os.path.join(path,filename)))\n text = \"\"\n \n for pages in doc:\n text = text + str(pages.getText())\n txt = \" \".join(text.split(\"\\n\"))\n return txt\n \n\n\ndef gen_test_data_for_pred(path,filename):\n test = red_pdf(path,filename)\n snow = nltk.stem.SnowballStemmer('english')\n corpus_test = []\n # for i in range(0, len(df)):\n review = re.sub('[^a-zA-Z]', ' ', test)\n review = review.lower()\n review = review.split()\n \n review = [snow.stem(word) for word in review if not word in stopwords.words('english')]\n review = ' '.join(review)\n corpus_test.append(review)\n\n final_tf_test = corpus_test\n # tf_idf = TfidfVectorizer(ngram_range=(1,2),max_features=5000)\n tf_idf = pickle.load(open('tfidf_vectorizer.pkl','rb'))\n test_data = tf_idf.transform(final_tf_test)\n # tf_data_test.get_shape()\n return test_data\n\n \ndef prediction(path,filename):\n clf_model = pickle.load(open('rf_score_model.pkl','rb'))\n result = clf_model.predict(gen_test_data_for_pred(path,filename))\n return result\n \n \ndef custom_NER(path,filename):\n model = spacy.load('resume_sum')\n txt=red_pdf(path,filename)\n \n# snow = nltk.stem.SnowballStemmer('english')\n# corpus_test_ner = []\n# review = re.sub('[^a-zA-Z]', ' ', txt)\n# review = review.lower()\n# review = review.split()\n \n# review = [snow.stem(word) for word in review if not word in stopwords.words('english')]\n# review = ' '.join(review)\n# corpus_test_ner.append(review)\n# corpus_test_ner = str(corpus_test_ner)\n doc = model(txt)\n abc = doc.ents\n return abc\n \n \n \n \n \n \n \n \nif __name__=='__main__':\n txt = red_pdf(path,filename)\n print(type(txt))\n print(txt)\n# s = custom_NER(path,filename)\n# lists = []\n# s=list(s)\n# for i in range(len(s)):\n# lists.append(str(s[i]))\n# print(tuple(lists))\n# # s[i] = str(s[i])\n \n\n# # print(type(s[i]))\n \n ", "<class 'str'>\nAnubhav Singh Email: [email protected] Portfolio: xprilion.com Mobile: +91-700-3944-046 Github: github.com/xprilion Education • Netaji Subhash Engineering College Kolkata, India Bachelor of Technology - Information Technology; GPA: 7.27 July 2016 - June 2020 Courses: Operating Systems, Data Structures, Analysis Of Algorithms, Artificial Intelligence, Machine Learning, Networking, Databases Skills Summary • Languages: Python, PHP, C++, JavaScript, SQL, Bash, JAVA • Frameworks: Scikit, NLTK, SpaCy, TensorFlow, Keras, Django, Flask, NodeJS, LAMP • Tools: Kubernetes, Docker, GIT, PostgreSQL, MySQL, SQLite • Platforms: Linux, Web, Windows, Arduino, Raspberry, AWS, GCP, Alibaba Cloud, IBM Cloud • Soft Skills: Leadership, Event Management, Writing, Public Speaking, Time Management Experience • Google Summer of Code - Submitty Remote Student Developer (Full-time) May 2019 - Sep 2019 ◦ Discussion Forum Upgrades: Refactor forum for performance to handle large databases. ◦ REST API for Discussion Forum: Symphony & Twig based Forum parts converted to API-first interface. ◦ Ratchet PHP WebSocket: Implemented a WebSocket for low-latency real time exchange of posts and thread updates. • DataCamp Inc. Remote Instructor (Part-time, Contractual) Dec 2018 - Present ◦ Project Course - Find Movie Similarity from Plot Summaries: Created project based course using Unsupervised learning and natural language processing. ◦ Tutorial - Introduction to Reinforcement Learning: Created tutorial for Q-learning RL algorithm and concepts. ◦ Impact: Course has been taken by 250+ students so far with 4.65 average rating. Projects • Vison - multimedia search engine (NLP, Search Engine, Web Crawlers, Multimedia Processing): (Work in progress) Research oriented, open source, search engine for bringing reverse multimedia search to small & mid scale enterprises. Tech: Python, NodeJS, Intel OpenVino Toolkit, Selenium, TensorFlow (October ’18) • Reinforcement Learning based Traffic Control System (Reinforcement Learning, Computer Vision): AI model to resolve city traffic around 50% faster. Tech: Python, Alibaba Cloud, Raspberry Pi, Arduino, SUMO & OpenCV. (August ’18) • Panorama from Satellite Imagery using Distributed Computing (Distributed Computing, Image Processing): Images clicked using drones, provided by ISRO were stitched together using distributed public compute nodes, effectively bringing down processing time exponentially. Tech: PHP, C++, Java, Python (March ’18) • Drag-n-drop machine learning learning environment (Web Development, Machine Learning): Scratch like tool for implementing machine learning pipelines along with built in tutorial for each concept. Tech: Python, JavaScript (September ’18) • Search Engine and Social Network(Web Development, Web Crawler, Search): Created from scratch a social network and a search engine based on the idea of integrating Facebook and Google. The launched website was among top 1000 websites in India during 2012-2013. Tech: PHP, MySQL, HTML, CSS, WebSockets, JavaScript, RSS, XML ( May ’12) Publications • Book: Deep Learning on Web (Web Development, Deep Learning): Work in Progress book to be published by Packt Publishing in late 2019. Tech: Django, Python, AWS, GCP, Azure (November ’18) • Book: Deep Learning on Mobile Devices (Flutter App Development, Deep Learning): Work in Progress book to be published by Packt Publishing in late 2019. Tech: Flutter, Android, Firebase, TensorFlow, Python, Dart (December ’18) Honors and Awards • Awarded title of Intel Software Innovator - May, 2019 • Second Runner’s Up at TCS EngiNx Engineering Project Innovation Content - September, 2018 • Runner’s Up at Facebook Developers Circle Hackathon - August, 2017 Volunteer Experience • Community Lead at Developer Student Clubs NSEC Kolkata, India Conducted online and offline technical & soft-skills training impacting over 3000 students. Jan 2019 - Present • Event Organizer at Google Developers Group Kolkata Kolkata, India Organized events, conducted workshops and delivered workshops reaching over 7000 developers. Jan 2018 - Present \n" ], [ "os.path.join(path, filename)", "_____no_output_____" ], [ "absja=('Anubhav Singh', 'Netaji Subhash Engineering', 'Kolkata', 'Community Lead')\n", "_____no_output_____" ], [ "absja='ada'\nprint(absja)", "ada\n" ], [ "len(Anubhav Singh, Netaji Subhash Engineering, Kolkata, Community Lead)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline", "_____no_output_____" ], [ "df_train = pd.read_csv(\"train.csv\")\ndf_test = pd.read_csv(\"test.csv\")", "_____no_output_____" ], [ "df_train.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 891 entries, 0 to 890\nData columns (total 12 columns):\nPassengerId 891 non-null int64\nSurvived 891 non-null int64\nPclass 891 non-null int64\nName 891 non-null object\nSex 891 non-null object\nAge 714 non-null float64\nSibSp 891 non-null int64\nParch 891 non-null int64\nTicket 891 non-null object\nFare 891 non-null float64\nCabin 204 non-null object\nEmbarked 889 non-null object\ndtypes: float64(2), int64(5), object(5)\nmemory usage: 83.6+ KB\n" ], [ "df_train.drop(labels=['Ticket', 'Cabin', 'Name'], inplace=True, axis=1)\ndf_test.drop(labels=['Ticket', 'Cabin', 'Name'], inplace=True, axis=1)\n\ndf_train.dropna(subset=['Embarked'], inplace=True)#Exists value nan\ndf_test.dropna(subset=['Embarked'], inplace=True)", "_____no_output_____" ], [ "lista = (df_train.dtypes == 'object')\nobject_cols = list(lista[lista].index)\n\nprint(\"Variáveis Categóricas:\")\nprint(object_cols)", "Variáveis Categóricas:\n['Sex', 'Embarked']\n" ], [ "df_train.fillna(value={'Age': df_train['Age'].median()}, inplace=True)\ndf_test.fillna(value={'Age': df_test['Age'].median()}, inplace=True)\n\ndf_test.fillna(value={'Fare': df_test['Fare'].median()}, inplace=True)", "_____no_output_____" ], [ "df_train.info()", "<class 'pandas.core.frame.DataFrame'>\nInt64Index: 889 entries, 0 to 890\nData columns (total 9 columns):\nPassengerId 889 non-null int64\nSurvived 889 non-null int64\nPclass 889 non-null int64\nSex 889 non-null object\nAge 889 non-null float64\nSibSp 889 non-null int64\nParch 889 non-null int64\nFare 889 non-null float64\nEmbarked 889 non-null object\ndtypes: float64(2), int64(5), object(2)\nmemory usage: 69.5+ KB\n" ], [ "from sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import metrics\n\nX = df_train[['Sex', 'Pclass', 'SibSp', 'Embarked', 'PassengerId', 'Age', 'Parch', 'Fare']]\ny = df_train['Survived']\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)\n\nclassifier = RandomForestClassifier(n_jobs=4, random_state=12)", "C:\\Anaconda3\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n from numpy.core.umath_tests import inner1d\n" ], [ "def score_dataset(X_train, X_valid, y_train, y_valid):\n classifier.fit(X_train, y_train)\n predicoes = classifier.predict(X_valid) \n print(metrics.classification_report(y_test, predicoes, target_names=['No', 'Yes']))", "_____no_output_____" ], [ "drop_X_train = X_train.select_dtypes(exclude=['object'])\ndrop_X_valid = X_test.select_dtypes(exclude=['object'])\n\nprint(\"Approach 1 (Drop categorical variables):\")\nprint(score_dataset(drop_X_train, drop_X_valid, y_train, y_test))", "Approach 1 (Drop categorical variables):\n precision recall f1-score support\n\n No 0.71 0.79 0.75 184\n Yes 0.56 0.45 0.50 110\n\navg / total 0.65 0.66 0.65 294\n\nNone\n" ], [ "from sklearn.preprocessing import LabelEncoder\n\n# Make copy to avoid changing original data \nlabel_X_train = X_train.copy()\nlabel_X_valid = X_test.copy()\n\n# Apply label encoder to each column with categorical data\nlabel_encoder = LabelEncoder()\nfor col in object_cols:\n label_X_train[col] = label_encoder.fit_transform(X_train[col])\n label_X_valid[col] = label_encoder.transform(X_test[col])\n\nprint(\"Approach 2 (Label Encoding):\") \nprint(score_dataset(label_X_train, label_X_valid, y_train, y_test))", "Approach 2 (Label Encoding):\n precision recall f1-score support\n\n No 0.81 0.87 0.84 184\n Yes 0.75 0.65 0.70 110\n\navg / total 0.79 0.79 0.79 294\n\nNone\n" ], [ "X_train[object_cols]", "_____no_output_____" ], [ "from sklearn.preprocessing import OneHotEncoder\n\n# Apply one-hot encoder to each column with categorical data\nOH_encoder = OneHotEncoder(handle_unknown='ignore', sparse=False, categories='auto')\n#OH_cols_train = pd.DataFrame(OH_encoder.fit_transform(X_train[object_cols]))\n#OH_cols_valid = pd.DataFrame(OH_encoder.transform(X_test[object_cols]))\n\nfor col in object_cols:\n X_train[col] = pd.Categorical(X_train[col])\n OH_cols_train[col] = OH_encoder.fit_transform(X_train[col].reshape(-1, 1))\n OH_cols_valid[col] = OH_encoder.transform(X_test[col])\n\n# One-hot encoding removed index; put it back\nOH_cols_train.index = X_train.index\nOH_cols_valid.index = X_test.index\n\n# Remove categorical columns (will replace with one-hot encoding)\nnum_X_train = X_train.drop(object_cols, axis=1)\nnum_X_valid = X_test.drop(object_cols, axis=1)\n\n# Add one-hot encoded columns to numerical features\nOH_X_train = pd.concat([num_X_train, OH_cols_train], axis=1)\nOH_X_valid = pd.concat([num_X_valid, OH_cols_valid], axis=1)\n\nprint(\"MAE from Approach 3 (One-Hot Encoding):\") \nprint(score_dataset(OH_X_train, OH_X_valid, y_train, y_test))", "C:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:9: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n if __name__ == '__main__':\n" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## Demo: Wrapped single_run_process\nThe basic steps to set up an OpenCLSim simulation are:\n* Import libraries\n* Initialise simpy environment\n* Define object classes\n* Create objects\n * Create sites\n * Create vessels\n * Create activities\n* Register processes and run simpy\n\n----\n\nThis notebook provides an example of a single_run_process. In the single_run_process a typical \"loading-sailing full-unloading-sailing empty\" is pre-packed in a while activity. ", "_____no_output_____" ], [ "#### 0. Import libraries", "_____no_output_____" ] ], [ [ "import datetime, time\nimport simpy\n\nimport shapely.geometry\nimport pandas as pd\n\nimport openclsim.core as core\nimport openclsim.model as model\nimport openclsim.plot as plot", "_____no_output_____" ] ], [ [ "#### 1. Initialise simpy environment", "_____no_output_____" ] ], [ [ "# setup environment\nsimulation_start = 0\nmy_env = simpy.Environment(initial_time=simulation_start)", "_____no_output_____" ] ], [ [ "#### 2. Define object classes", "_____no_output_____" ] ], [ [ "# create a Site object based on desired mixin classes\nSite = type(\n \"Site\",\n (\n core.Identifiable,\n core.Log,\n core.Locatable,\n core.HasContainer,\n core.HasResource,\n ),\n {},\n)\n\n# create a TransportProcessingResource object based on desired mixin classes\nTransportProcessingResource = type(\n \"TransportProcessingResource\",\n (\n core.Identifiable,\n core.Log,\n core.ContainerDependentMovable,\n core.Processor,\n core.HasResource,\n core.LoadingFunction,\n core.UnloadingFunction,\n ),\n {},\n)", "_____no_output_____" ] ], [ [ "#### 3. Create objects\n##### 3.1. Create site object(s)", "_____no_output_____" ] ], [ [ "# prepare input data for from_site\nlocation_from_site = shapely.geometry.Point(4.18055556, 52.18664444)\ndata_from_site = {\"env\": my_env,\n \"name\": \"from_site\",\n \"geometry\": location_from_site,\n \"capacity\": 10_000,\n \"level\": 10_000\n }\n# instantiate from_site \nfrom_site = Site(**data_from_site)\n\n# prepare input data for to_site\nlocation_to_site = shapely.geometry.Point(4.25222222, 52.11428333)\ndata_to_site = {\"env\": my_env,\n \"name\": \"to_site\",\n \"geometry\": location_to_site,\n \"capacity\": 10_000,\n \"level\": 0\n }\n# instantiate to_site \nto_site = Site(**data_to_site)", "_____no_output_____" ] ], [ [ "##### 3.2. Create vessel object(s)", "_____no_output_____" ] ], [ [ "# prepare input data for vessel_01\ndata_vessel01 = {\"env\": my_env,\n \"name\": \"vessel01\",\n \"geometry\": location_from_site, \n \"loading_rate\": 1,\n \"unloading_rate\": 5,\n \"capacity\": 1_000,\n \"compute_v\": lambda x: 10 + 2 * x\n }\n# instantiate vessel_01 \nvessel01 = TransportProcessingResource(**data_vessel01)", "_____no_output_____" ] ], [ [ "##### 3.3 Create activity/activities", "_____no_output_____" ] ], [ [ "# initialise registry\nregistry = {}", "_____no_output_____" ], [ "# create a 'while activity' that contains a pre-packed set of 'sub_processes'\nsingle_run, while_activity = model.single_run_process(\n name=\"single_run\",\n registry={},\n env=my_env,\n origin=from_site,\n destination=to_site,\n mover=vessel01,\n loader=vessel01,\n unloader=vessel01\n)", "_____no_output_____" ] ], [ [ "#### 4. Register processes and run simpy", "_____no_output_____" ] ], [ [ "# initate the simpy processes defined in the 'while activity' and run simpy\nmodel.register_processes([while_activity])\nmy_env.run()", "_____no_output_____" ] ], [ [ "#### 5. Inspect results\n##### 5.1 Inspect logs", "_____no_output_____" ] ], [ [ "display(plot.get_log_dataframe(vessel01, [*single_run, while_activity]))", "_____no_output_____" ], [ "display(plot.get_log_dataframe(from_site, [*single_run]))", "_____no_output_____" ], [ "display(plot.get_log_dataframe(to_site, [*single_run]))", "_____no_output_____" ] ], [ [ "##### 5.2 Visualise gantt charts", "_____no_output_____" ] ], [ [ "plot.get_gantt_chart([while_activity, vessel01, *single_run])", "_____no_output_____" ] ], [ [ "##### 5.3 Visualise step charts", "_____no_output_____" ] ], [ [ "fig = plot.get_step_chart([from_site, to_site, vessel01])", "_____no_output_____" ] ], [ [ "You can observe in the step chart that the loading rate of vessel01 is 1 and the unloading rate is 5. This is clearly visible in the longer time it takes to transfer the cargo from from_site to vessel01, than it takes to transfer the cargo from vessel_1 to to_site. ", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# a) By using Logistic Regression Algorithm", "_____no_output_____" ], [ "# Part A: Data Preprocessing", "_____no_output_____" ], [ "# Step1 : importing the libraries", "_____no_output_____" ] ], [ [ "import numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd", "_____no_output_____" ] ], [ [ "# step2: import data set", "_____no_output_____" ] ], [ [ "dataset=pd.read_csv('Logistic Data.csv')", "_____no_output_____" ], [ "dataset", "_____no_output_____" ] ], [ [ "# step3: to create feature matrix and dependent variable vector", "_____no_output_____" ] ], [ [ "a=dataset.iloc[:,:-1].values\nb=dataset.iloc[:,-1].values", "_____no_output_____" ], [ "a", "_____no_output_____" ], [ "b", "_____no_output_____" ] ], [ [ "# step4: replace the missing data", "_____no_output_____" ] ], [ [ "from sklearn.impute import SimpleImputer\nimputer=SimpleImputer(missing_values=np.nan,strategy='mean')\nimputer.fit(a[:,:])\na[:,:]=imputer.transform(a[:,:])", "_____no_output_____" ], [ "a", "_____no_output_____" ], [ "b", "_____no_output_____" ] ], [ [ "# Step5: Encoding(not required)", "_____no_output_____" ], [ "# step6 : spiliting of data set into training and testing set", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import train_test_split\natrain,atest,btrain,btest=train_test_split(a,b,test_size=0.2,random_state=1)", "_____no_output_____" ], [ "atrain", "_____no_output_____" ] ], [ [ "# step7 : Feature scaling", "_____no_output_____" ] ], [ [ "from sklearn.preprocessing import StandardScaler\nsc=StandardScaler()\natrain=sc.fit_transform(atrain)\natest=sc.fit_transform(atest)", "_____no_output_____" ], [ "atrain", "_____no_output_____" ] ], [ [ "# Part B: build my first linear model", "_____no_output_____" ], [ "# step 1: training the classification model", "_____no_output_____" ] ], [ [ "from sklearn.linear_model import LogisticRegression\nLoR=LogisticRegression(random_state=0)\nLoR.fit(atrain,btrain)", "_____no_output_____" ] ], [ [ "# step 2: testing the linear model", "_____no_output_____" ] ], [ [ "bestimated=LoR.predict(atest)\nprint(np.concatenate((bestimated.reshape(len(bestimated),1),btest.reshape(len(btest),1)),1))", "[[0 0]\n [0 0]\n [0 1]\n [1 1]\n [0 0]\n [0 0]\n [0 0]\n [1 1]\n [0 0]\n [1 0]\n [0 0]\n [0 0]\n [0 0]\n [1 1]\n [1 1]\n [1 1]\n [1 1]\n [0 0]\n [0 0]\n [1 1]\n [0 0]\n [1 1]\n [1 1]\n [0 0]\n [0 1]\n [0 0]\n [1 1]\n [1 0]\n [1 1]\n [1 0]\n [0 0]\n [0 0]\n [0 0]\n [1 1]\n [0 0]\n [0 0]\n [0 0]\n [0 0]\n [0 1]\n [0 0]\n [1 1]\n [1 1]\n [0 0]\n [0 0]\n [1 1]\n [0 1]\n [0 1]\n [1 1]\n [0 0]\n [1 1]\n [0 0]\n [0 0]\n [0 1]\n [0 1]\n [0 1]\n [0 0]\n [1 1]\n [0 0]\n [1 1]\n [1 1]\n [0 0]\n [0 0]\n [0 0]\n [0 0]\n [0 1]\n [1 1]\n [0 0]\n [0 0]\n [1 0]\n [0 0]\n [1 0]\n [0 0]\n [0 1]\n [0 0]\n [0 0]\n [1 1]\n [0 0]\n [0 0]\n [0 0]\n [0 0]]\n" ] ], [ [ "# step C: performance matrix", "_____no_output_____" ] ], [ [ "from sklearn.metrics import confusion_matrix,accuracy_score,precision_score\ncm=confusion_matrix(btest,bestimated)\nprint(cm)\nprint(accuracy_score(btest,bestimated))\nprint(precision_score(btest,bestimated))", "[[43 5]\n [10 22]]\n0.8125\n0.8148148148148148\n" ], [ "np.mean((True,True,False))", "_____no_output_____" ], [ "error_rate=[]\nfor i in range(1,30):\n KC=KNeighborsClassifier(n_neighbors=i)\n KC.fit(atrain,btrain)\n bpred_i=KC.predict(atest)\n error_rate.append(np.mean(bpred_i!=btest))", "_____no_output_____" ], [ "plt.plot(range(1,30),error_rate,marker='o',markerfacecolor='red',markersize=5)\nplt.xlabel('K value')\nplt.ylabel('Error rate')", "_____no_output_____" ] ], [ [ "# b) By using KNN Algorithm", "_____no_output_____" ], [ "# Part A: Data Preprocessing", "_____no_output_____" ], [ "# Step1 : importing the libraries", "_____no_output_____" ] ], [ [ "import numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd", "_____no_output_____" ] ], [ [ "# step2: import data set", "_____no_output_____" ] ], [ [ "dataset=pd.read_csv('Logistic Data.csv')", "_____no_output_____" ], [ "dataset", "_____no_output_____" ] ], [ [ "# step3: to create feature matrix and dependent variable vector", "_____no_output_____" ] ], [ [ "a=dataset.iloc[:,:-1].values\nb=dataset.iloc[:,-1].values", "_____no_output_____" ], [ "a", "_____no_output_____" ], [ "b", "_____no_output_____" ] ], [ [ "# step4: replace the missing data", "_____no_output_____" ] ], [ [ "from sklearn.impute import SimpleImputer\nimputer=SimpleImputer(missing_values=np.nan,strategy='mean')\nimputer.fit(a[:,:])\na[:,:]=imputer.transform(a[:,:])", "_____no_output_____" ], [ "a", "_____no_output_____" ] ], [ [ "# Step5: Encoding(not required)", "_____no_output_____" ], [ "# step6 : spiliting of data set into training and testing set", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import train_test_split\natrain,atest,btrain,btest=train_test_split(a,b,test_size=0.2,random_state=1)", "_____no_output_____" ], [ "atrain", "_____no_output_____" ] ], [ [ "# step7 : Feature scaling", "_____no_output_____" ] ], [ [ "from sklearn.preprocessing import StandardScaler\nsc=StandardScaler()\natrain=sc.fit_transform(atrain)\natest=sc.fit_transform(atest)", "_____no_output_____" ], [ "atrain", "_____no_output_____" ] ], [ [ "# Part B: build my KNN classification model", "_____no_output_____" ], [ "# step 1: training the classification model", "_____no_output_____" ] ], [ [ "from sklearn.neighbors import KNeighborsClassifier\nKC=KNeighborsClassifier(n_neighbors=7,weights='uniform',p=2)\nKC.fit(atrain,btrain)", "_____no_output_____" ] ], [ [ "# step 2: testing the linear model", "_____no_output_____" ] ], [ [ "bestimated=KC.predict(atest)", "_____no_output_____" ] ], [ [ "# step C: performance matrix", "_____no_output_____" ] ], [ [ "from sklearn.metrics import confusion_matrix,accuracy_score,precision_score\ncm=confusion_matrix(btest,bestimated)\nprint(cm)\nprint(accuracy_score(btest,bestimated))\nprint(precision_score(btest,bestimated))", "[[42 6]\n [ 2 30]]\n0.9\n0.8333333333333334\n" ], [ "np.mean((True,True,False))", "_____no_output_____" ], [ "error_rate=[]\nfor i in range(1,30):\n KC=KNeighborsClassifier(n_neighbors=i)\n KC.fit(atrain,btrain)\n bpred_i=KC.predict(atest)\n error_rate.append(np.mean(bpred_i!=btest))", "_____no_output_____" ], [ "plt.plot(range(1,30),error_rate,marker='o',markerfacecolor='red',markersize=5)\nplt.xlabel('K value')\nplt.ylabel('Error rate')", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "def number_value(text):\n tempo=[]\n alpha=\"abcdefghijklmnopqrstuvwxyz\"\n alphacap=\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n for i in range(len(text)):\n value=alpha.find(text[i])\n if value == -1:\n value=alphacap.find(text[i])\n tempo.append(value)\n return tempo\ndef alpha_value(number):\n alpha=\"abcdefghijklmnopqrstuvwxyz\"\n return alpha[number]", "_____no_output_____" ], [ "def cipher_encryption(text,key):\n tempo1=[]\n text_numbered=number_value(text)\n key_numbered=number_value(key)\n for i in range(len(text_numbered)):\n if text_numbered[i]==-1:\n tempo1.append(' ')\n else:\n calc=((text_numbered[i]+key_numbered[i])%26)\n alpha=alpha_value(calc)\n tempo1.append(alpha)\n return tempo1", "_____no_output_____" ], [ "def cipher_decryption(text,key):\n tempo2=[]\n text_numbered=number_value(text)\n key_numbered=number_value(key)\n for i in range(len(text_numbered)):\n if text_numbered[i]==-1:\n tempo2.append(' ')\n else:\n calc=((text_numbered[i]-key_numbered[i])%26)\n alpha=alpha_value(calc)\n tempo2.append(alpha)\n return tempo2", "_____no_output_____" ], [ "print(\"This is Vignere Cipher Encrtption and Decryption \\nEnter \\n1. For Encryption \\n2. For Decryption\")\nchoice=int(input())\nif choice == 1:\n plain_text=input(\"plain text and Enter Key\\n\")\n key=input()\n if len(key)<len(plain_text):\n size=len(plain_text)-len(key)\n for i in range(size):\n key += (key[i])\n cipher_text=cipher_encryption(plain_text,key)\n out=''\n for i in cipher_text:\n out+=str(i)\n print(out) \n\nelif choice == 2:\n cipher_text=input(\"cipher text and Enter Key\\n\")\n key=input()\n if len(key)<len(cipher_text):\n size=len(cipher_text)-len(key)\n for i in range(size):\n key += (key[i])\n plain_text=cipher_decryption(cipher_text,key)\n out1=''\n for i in plain_text:\n out1 +=str(i)\n print(out1) \n \nelse: print(\"invalid\")", "This is Vignere Cipher Encrtption and Decryption \nEnter \n1. For Encryption \n2. For Decryption\n1\nplain text and Enter Key\nEducation can be thought of as the transmission of the values and accumulated knowledge of a society. In this sense, it is equivalent to what social scientists term socialization or enculturation. Children—whether conceived among New Guinea tribespeople, the Renaissance Florentines, or the middle classes of Manhattan—are born without culture. Education is designed to guide them in learning a culture, molding their behaviour in the ways of adulthood, and directing them toward their eventual role in society. In the most primitive cultures, there is often little formal learning—little of what one would ordinarily call school or classes or teachers. Instead, the entire environment and all activities are frequently viewed as school and classes, and many or all adults act as teachers. \nbin\nflhdigjwa kno of giwhhpg ws if buf gsiatuvtavpv pn upr dnmcrt nol bkpvuhmigfl lvbxtreor ws i twpjmgz jv upvt ffvff jb ja fyhjdnmmau gp jiig abdqnm fdqrobvtbf brsu twpjiyjhnuqbo bs rokhmbhsigjwa piqyezro jimgime kbokrjdre nnwah afe hcvomn bejjrtxrpxyf upr zroivtanokr nypzrobvomf bs gim nqqetr kybaffa pn niaiiguia ief opza evupbvb dcyucef flhdigjwa qf lrtqtomq bb ohjlr bufu jv mmnsvvoo b pvtgvzr zptqjvt bufqe jriiijwhs vo gim xilt bg necyupbpl iae qjzrdbvoo uprn gpensl uprjz fdrobhbt swyf vo fpkvfbl vo gim nwfu csqzjbvwm dcyucefa bufzr qf wsuma tvubyf spzzbt mmnsvvoo mqgutr ws eubb pvr ebvtq weeqabzvmg diym fdpbpt pz dtntart bs gfipimet jvfumne upr mauqef rodvswanmau nol bty ipuqijbvfa bzr nefyhfvgmg wqrxmq if apiwbm nol dtntart bvq unog pz bty iqvtgt ndb ba umndprsa \n" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# CNN Basic\n> In this post, We will dig into the basic operation of Convolutional Neural Network, and explain about what each layer look like. And we will simply implement the basic CNN archiecture with tensorflow.\n\n- toc: true \n- badges: true\n- comments: true\n- author: Chanseok Kang\n- categories: [Python, Deep_Learning, Tensorflow-Keras]\n- image: images/cnn_stacked.png", "_____no_output_____" ] ], [ [ "import tensorflow as tf\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\nplt.rcParams['figure.figsize'] = (16, 10)\nplt.rc('font', size=15)", "_____no_output_____" ] ], [ [ "## Convolutional Neural Network\n [Convolutional Neural Network](https://en.wikipedia.org/wiki/Convolutional_neural_network) (CNN for short) is the most widely used for image classification. Previously, we handled image classification problem (Fashion-MNIST) with Multi Layer Perceptron, and we found that works. At that time, the information containing each image is very simple, and definitely classified with several parameters. But if the dataset contains high resolution image and several channels, it may require huge amount of parameters with mlp in image classification. How can we effectively classify the image without huge amount of parameters? And that's why the CNN exists.\n \n\n*Fig 1. Example of Convolutional Neural Network*\n \n Generally, it consists of **Convolution layer**, **Pooling layer**, and **Fully-connected layer**. Usually, Convolution layer and Pooling layer is used for feature extraction. Feature extraction means that it extract important features from image for classification, so that all pixels in images is not required. Through these layer, information of data is resampled, and refined, and go to the output node. Fully-connected (also known as FC) is used for classification.", "_____no_output_____" ], [ "### 2D Convolution Layer\nTo understand convolution layer, we need to see the shape of image and some elements to extract features called filters(also called kernel).\n\n\n\nIn Fashion-MNIST example, the image containing dataset is grayscale. So the range of pixel value is from 0 to 255. But most of real-world image and all the things we see now is colorized. Technically, it can expressed with 3 base color, Red, Green, Blue. The color system which can express these 3 colors are called **RGB**, and each range of pixel value is also from 0 to 255, same as grayscaled pixel.\n\n> Note: There are other color systems like RGBA (Red-Green-Blue-Alpha) or HSV (Hue-Saturation-Value), HSL (Hue-Saturation-Lightness), etc. In this post, we just assume that image has 3 channels (RGB)\n\nSo In the figure, this image has shape of 32x32 and 3 channels (RGB).\n\nAnd Next one is the filter, which shape has 5x5x3. The number we need to focus on **3**. Filter always extend the full channel of the input volume. So it requires to set same number of channels in input nodes and filters. \n\nAs you can see, filter has same channel with input image. And let's assume the notation of filter, $w$. Next thing we need to do is just slide th filter over the image spatially, and compute dot products, same as MLP operation (This operation is called **convolution**, and it's the reason why this layer is called Convolution layer). Simply speaking, we just focus on the range covered in filter and dot product like this,\n\n$$ w^T x + b $$\n\nOf course, we move the filter until it can operate convolution.\n\n\n*Fig 3. Animation of convolution operation\n\nAfter that, (Assume we don't apply padding, and stride is 1), we can get output volume which shape has 28x28x1. There is formula to calculate the shape of output volume when the stride and filter is defined,\n\n$$ \\frac{(\\text{Height of input} - \\text{Height of filter})}{\\text{Stride}} + 1 $$\n\nWe can substitute the number in this formula, then we can conclude the height of output volume is 28. The output the process convolution is called **Feature Map** (or Activation Map). One feature map gather from one filter, we can apply several filters in one input image. If we use 6 5x5 filters, we can get 6 separate feature maps. We can stack them into one object, then we get \"new image\" of size 28x28x6.\n\n\n<p>\n <em>Fig 4. stacked output of convolution</em>\n</p>\n\nHere, one number is need to focus, **6**. 6 means the number of filters we apply in this convolution layer.\n\nYou may be curious about what filter looks like. Actually, filter was widely used from classic computer vision. For example, to extract the edge of object in image, we can apply the *canny edge filer*, and there is edge detection filter named *sobel filter*, and so on. We can bring the concept of filter in CNN here. In short, filter extract the feature like where the edge is, and convolution layer refine its feature.\n\n\n*Fig 5. Applying filter for each pixel*\n\nHere, we just consider the one channel of image and apply it with 6 filters. And we can extend it in multi-channel, and lots of filters.\n\n\n*Fig 6. Convolution operation in many channels and many filters*", "_____no_output_____" ], [ "### Options of Convolution\n\nSo what parameteter may affect operation in convolution layer? We can introduce three main parameters for convolution layer: stride, zero-padding, and activation function.\n\n**Stride** is the size of step that how far to go to the right or the bottom to perform the next convolution. It is important that it defines the output model's size. Review the formula of calculating the feature map size,\n\n$$ \\frac{(\\text{Height of input} - \\text{Height of filter})}{\\text{Stride}} + 1 $$\n\nWe can define any size of strides unless its value is smaller than original model size. As we increase the stride, then the size of feature map will be small, and it means that feature will also be small. Think about that the picture is summarized by just a small dot.\n\n**Zero-padding** is another factor that affect the convolution layer. The meaning is contained in its name. A few numbers of zeros surrounds the original image, then process the convolution operation. As we can see from previous process, if the layer is deeper and deeper, then the information will be smaller the original one due to the convolution operation. To preserve the size of original image during process, zero-padding is required. If the filter size is FxF and stride is 1, then we can also calculate the zero-padding size,\n\n$$ \\frac{F - 1}{2} $$\n\nYou may see the **Activation Function** in MLP. It can also apply in the Convolution layer.\nFor example, when we apply Rectified Linear Unit (ReLU) in feature map, we can remove the value that lower than 0,", "_____no_output_____" ], [ "### Convolution Layer in Tensorflow\nLet's look at how we can use Convolution layer in tensorflow. Actually, in Tensorflow v2.x, Convolution layer is implemented in keras as an high-level class, so all we need to do is just defineing the parameters correctly. Here is the `__init__` of `tf.keras.layers.Conv2D`.\n\n```python\ntf.keras.layers.Conv2D(\n filters, kernel_size, strides=(1, 1), padding='valid', data_format=None,\n dilation_rate=(1, 1), groups=1, activation=None, use_bias=True,\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\n kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None,\n kernel_constraint=None, bias_constraint=None, **kwargs\n)\n```\n\nWe already covered filters, kernel_size (same as filter_size), strides, and so on. Here is brief description of arguments:\n\n| arguments | |\n| --- | --- |\n| filters | Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). |\n| kernel_size | An integer or tuple/list of 2 integers, specifying the height and width of the 2D convolution window. Can be a single integer to specify the same value for all spatial dimensions. |\n| strides | An integer or tuple/list of 2 integers, specifying the strides of the convolution along the height and width. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any dilation_rate value != 1. |\n| padding | one of \"valid\" or \"same\" (case-insensitive). |\n| data_format | A string, one of channels_last (default) or channels_first. The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, height, width, channels) while channels_first corresponds to inputs with shape (batch_size, channels,height, width). It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be channels_last. |\n| activation | Activation function to use. If you don't specify anything, no activation is applied (see [keras.activations](https://www.tensorflow.org/api_docs/python/tf/keras/activations)). |\n| use_bias | Boolean, whether the layer uses a bias vector. |\n| kernel_initializer | Initializer for the kernel weights matrix |\n| bias_initializer | Initializer for the bias vector |\n\nWe need to focus on the `data_format`. The description said that the default value of data_format is 'channels_last'. It means that all data in this layer must follow in this format order: `(batch, height, width, channels)`\n\nAnd `padding` argument can accept `valid` and `same`. `same` means no zero-padding. In this case, it drops the last convolution if the dimensions do not match (or fraction). If you want to use zero-padding, then we need to define `padding` argument as `same`. In this case, it pads such that feature map size has same as original one.(That's why we call the `same`) Usually it is also called 'half' padding.", "_____no_output_____" ], [ "### Example with Toy Image\nLet's use the convolution layer. For the simplicity, we will use a simple toy image, then see the output.", "_____no_output_____" ] ], [ [ "image = tf.constant([[[[1], [2], [3]], \n [[4], [5], [6]],\n [[7], [8], [9]]]], dtype=np.float32)\nfig, ax = plt.subplots()\nax.imshow(image.numpy().reshape(3, 3), cmap='gray')\n\nfor (j, i), label in np.ndenumerate(image.numpy().reshape(3, 3)):\n if label < image.numpy().mean():\n ax.text(i, j, label, ha='center', va='center', color='white')\n else:\n ax.text(i, j, label, ha='center', va='center', color='k')\nplt.show()", "_____no_output_____" ], [ "print(image.shape)", "(1, 3, 3, 1)\n" ] ], [ [ "We made a simple image that has size of 3x3. Rememeber that the order of data should be `(batch, height, width, channel)`. In this case, batch size is 1, and currently generates the grayscaled image, so the channel should be 1.\n\nThen, we need to define filter and kernel_size, and padding method. We will use one filter with all-one weight that has 2x2 shape.\n\nNote that we need to set the same format in image shape and filter. If not, following error will be occurred,\n\n```python\nValueError: setting an array element with a sequence.\n```", "_____no_output_____" ] ], [ [ "# Weight Initialization\nweight = np.array([[[[1.]], [[1.]]],\n [[[1.]], [[1.]]]])\nweight_init = tf.constant_initializer(weight)\nprint(\"weight.shape: {}\".format(weight.shape))\n\n# Convolution layer\nlayer = tf.keras.layers.Conv2D(filters=1, kernel_size=(2, 2), padding='VALID', kernel_initializer=weight_init)\noutput = layer(image)", "weight.shape: (2, 2, 1, 1)\n" ], [ "# Check the result\nfig, ax = plt.subplots()\nax.imshow(output.numpy().reshape(2, 2), cmap='gray')\nfor (j, i), label in np.ndenumerate(output.numpy().reshape(2, 2)):\n if label < output.numpy().mean():\n ax.text(i, j, label, ha='center', va='center', color='white')\n else:\n ax.text(i, j, label, ha='center', va='center', color='k')\n\nplt.show()", "_____no_output_____" ] ], [ [ "See? This is the output of convolution layer with toy image. In this time, change the padding argument from `VALID` to `SAME` and see the result. In this case, zero padding is added ('half' padding), so the output shape will be also changed.", "_____no_output_____" ] ], [ [ "# Convolution layer with half padding\nlayer = tf.keras.layers.Conv2D(filters=1, kernel_size=(2, 2), padding='SAME', kernel_initializer=weight_init)\noutput2 = layer(image)", "_____no_output_____" ], [ "# Check the result\nfig, ax = plt.subplots()\nax.imshow(output2.numpy().reshape(3, 3), cmap='gray')\nfor (j, i), label in np.ndenumerate(output2.numpy().reshape(3, 3)):\n if label < output2.numpy().mean():\n ax.text(i, j, label, ha='center', va='center', color='white')\n else:\n ax.text(i, j, label, ha='center', va='center', color='k')\nplt.show()", "_____no_output_____" ] ], [ [ "And what if we apply 3 filters in here?", "_____no_output_____" ] ], [ [ "# Weight initialization\nweight = np.array([[[[1., 10., -1.]], [[1., 10., -1.]]],\n [[[1., 10., -1.]], [[1., 10., -1.]]]])\nweight_init = tf.constant_initializer(weight)\nprint(\"Weight shape: {}\".format(weight.shape))\n\n# Convolution layer\nlayer = tf.keras.layers.Conv2D(filters=3, kernel_size=(2, 2), padding='SAME', kernel_initializer=weight_init)\noutput = layer(image)\n\n## Check output\nfeature_maps = np.swapaxes(output, 0, 3)\n\nfig, ax = plt.subplots(1, 3)\nfor x, feature_map in enumerate(feature_maps):\n ax[x].imshow(feature_map.reshape(3, 3), cmap='gray')\n for (j, i), label in np.ndenumerate(feature_map.reshape(3, 3)):\n if label < feature_map.mean():\n ax[x].text(i, j, label, ha='center', va='center', color='white')\n else:\n ax[x].text(i, j, label, ha='center', va='center', color='k')", "Weight shape: (2, 2, 1, 3)\n" ] ], [ [ "### Pooling Layer\nAfter passing Activation function, the output may be changed. We can summarize the output with some rules, for example, find the maximum pixel value in specific filter that assume to represent that field.\n\n\n*Fig 7, Max-Pooling*\n\nIn the figure, we use 2x2 filter for pixel handling. When the filter is slided by stride 2, filter find the maximum pixel value, and re-define it as an output.\n\nOr we can find the average pixel value in specific filter that assume to represent that field. Prior one is called **Max-Pooling**, and latter is called **Average-Pooling**. Usually, this kind of process is called **Sub-sampling**, since this process extract the important pixel(Max or Average) from the image, and the output size is reduced by half.", "_____no_output_____" ], [ "#### Max Pooling Layer in Tensorflow\nSame as Convolution Layer, Max Pooling Layer is also defined in Tensorflow-keras as a high level class. Here is the `__init__` of `tf.keras.layers.MaxPool2D`. (you can also check [AveragePooling2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D) in documentation)\n\n```python\ntf.keras.layers.MaxPool2D(\n pool_size=(2, 2), strides=None, padding='valid', data_format=None, **kwargs\n)\n```\n\nActually, it is almost same as that of convolution layer. `pool_size` argument is similar with `filter_size` in convolution layer, and it will define the range to extract the maximum value. Here is brief description of arguments:\n\n| arguments | |\n| --- | --- |\n| pool_size | integer or tuple of 2 integers, factors by which to downscale (vertical, horizontal). (2, 2) will halve the input in both spatial dimension. If only one integer is specified, the same window length will be used for both dimensions.\n |\n| strides | Integer, tuple of 2 integers, or None. Strides values. If None, it will default to pool_size.\n |\n| padding | One of \"valid\" or \"same\" (case-insensitive). |\n| data_format | A string, one of channels_last (default) or channels_first. The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch_size, height, width, channels) while channels_first corresponds to inputs with shape (batch_size, channels,height, width). It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be channels_last. |", "_____no_output_____" ], [ "### Example with Toy Image\nHere, we will check the Maxpooling operation with toy image.", "_____no_output_____" ] ], [ [ "# Sample image\nimage = tf.constant([[[[4.], [3.]],\n [[2.], [1.]]]], dtype=np.float32)", "_____no_output_____" ], [ "# Max Pooling layer\nlayer = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=1, padding='VALID')\noutput = layer(image)\n\n# Check the output\nprint(output.numpy())", "[[[[4.]]]]\n" ] ], [ [ "After that, we found out that the output of this image is just 4, the maximum value. How about the case with `SAME` padding?", "_____no_output_____" ] ], [ [ "layer = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=1, padding='SAME')\noutput = layer(image)\n\nprint(output.numpy())", "[[[[4.]\n [3.]]\n\n [[2.]\n [1.]]]]\n" ] ], [ [ "You may see that the output is different compared with previous one. That's because, while max pooling operation is held, zero-padding is also considered as an one pixel. So the 4 max-pooling operation is occurred.\n\n", "_____no_output_____" ], [ "## Convolution/MaxPooling in MNIST\nIn this case, we apply the convolution/MaxPooling operation in more specific dataset, the MNIST dataset. First, load the data. and normalize it. And see the sampled data.", "_____no_output_____" ] ], [ [ "(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()\n\n# Normalization\nX_train = X_train.astype(np.float32) / 255.\nX_test = X_test.astype(np.float32) / 255.\n\nimage = X_train[0]\nplt.imshow(image, cmap='gray')\nplt.show()", "_____no_output_____" ] ], [ [ "To handle this image in tensorflow, we need to convert it from 2d numpy array to 4D Tensor. There are several approaches to convert 4D tensor. One of approaches in Tensorflow is add `tf.newaxis` like this,", "_____no_output_____" ] ], [ [ "print(\"Dimension: {}\".format(image.shape))\nimage = image[tf.newaxis, ..., tf.newaxis]\nprint(\"Dimension: {}\".format(image.shape))\n\n# Convert it to tensor\nimage = tf.convert_to_tensor(image)", "Dimension: (28, 28)\nDimension: (1, 28, 28, 1)\n" ] ], [ [ "Same as before, we initialize the filter weight and apply it to convolution layer. In this case, we use 5 filters and (3, 3) filter size and stride to (2, 2), and padding is `SAME`.", "_____no_output_____" ] ], [ [ "weight_init = tf.keras.initializers.RandomNormal(stddev=0.01)\nlayer_conv = tf.keras.layers.Conv2D(filters=5, kernel_size=(3, 3), strides=(2, 2), padding='SAME',\n kernel_initializer=weight_init)\noutput = layer_conv(image)\nprint(output.shape)", "(1, 14, 14, 5)\n" ], [ "feature_maps = np.swapaxes(output, 0, 3)\n\nfig, ax = plt.subplots(1, 5)\nfor i, feature_map in enumerate(feature_maps):\n ax[i].imshow(feature_map.reshape(14, 14), cmap='gray')\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "After that, we use this output to push max-pooling layer as an input.", "_____no_output_____" ] ], [ [ "layer_pool = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='SAME')\noutput2 = layer_pool(output)\nprint(output2.shape)", "(1, 7, 7, 5)\n" ], [ "feature_maps = np.swapaxes(output2, 0, 3)\n\nfig, ax = plt.subplots(1, 5)\nfor i, feature_map in enumerate(feature_maps):\n ax[i].imshow(feature_map.reshape(7, 7), cmap='gray')\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "Using this, we extract the feature of input. Then we can use Fully-Connected Layer with softmax activation function for classification. (Actually, We already covered Fully-Connected layer with softmax activation function in previous post).", "_____no_output_____" ], [ "## Summary\nIn this post, We covered the definition of Convolutional Neural Network, and its basic opeartions, convolution and max-pooling. Unlike Artificial Neural Network, The purpose of these operation is actually to extract the feature and handle it efficiently without whole informations. We can use it in various ways, and of course, we can re-do the image classification with CNN, same as MLP.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ " # 0.0. IMPORTS", "_____no_output_____" ] ], [ [ "import math\nimport numpy as np\nimport pandas as pd\nimport inflection\n\nimport seaborn as sns\n\nfrom matplotlib import pyplot as plt\nfrom IPython.core.display import HTML", "_____no_output_____" ] ], [ [ "## 0.1. Helper Functions", "_____no_output_____" ] ], [ [ "def jupyter_settings():\n %matplotlib inline\n %pylab inline\n \n plt.style.use( 'bmh' )\n plt.rcParams['figure.figsize'] = [25, 12]\n plt.rcParams['font.size'] = 24\n \n display( HTML( '<style>.container { width:100% !important; }</style>') )\n pd.options.display.max_columns = None\n pd.options.display.max_rows = None\n pd.set_option( 'display.expand_frame_repr', False )\n \n sns.set()", "_____no_output_____" ], [ "jupyter_settings()", "Populating the interactive namespace from numpy and matplotlib\n" ] ], [ [ "## 0.2. Loading data", "_____no_output_____" ] ], [ [ "df_sales_raw = pd.read_csv( 'data/train.csv', low_memory=False )\ndf_store_raw = pd.read_csv( 'data/store.csv', low_memory=False )\n\n# merge\ndf_raw = pd.merge( df_sales_raw, df_store_raw, how='left', on='Store' )", "_____no_output_____" ] ], [ [ "# 1.0 DESCRIPCIÓN DE LOS DATOS", "_____no_output_____" ] ], [ [ "df1 = df_raw.copy()", "_____no_output_____" ] ], [ [ "## 1.1. Rename Columns", "_____no_output_____" ] ], [ [ "cols_old = ['Store', 'DayOfWeek', 'Date', 'Sales', 'Customers', 'Open', 'Promo', 'StateHoliday', 'SchoolHoliday', \n 'StoreType', 'Assortment', 'CompetitionDistance', 'CompetitionOpenSinceMonth',\n 'CompetitionOpenSinceYear', 'Promo2', 'Promo2SinceWeek', 'Promo2SinceYear', 'PromoInterval']\n\nsnakecase = lambda x: inflection.underscore( x )\n\ncols_new = list( map( snakecase, cols_old ) )\n\n# rename\ndf1.columns = cols_new", "_____no_output_____" ] ], [ [ "## 1.2. Data Dimensions", "_____no_output_____" ] ], [ [ "print( 'Number of Rows: {}'.format( df1.shape[0] ) )\nprint( 'Number of Cols: {}'.format( df1.shape[1] ) )\n\n", "Number of Rows: 1017209\nNumber of Cols: 18\n" ] ], [ [ "## 1.3. Data Types", "_____no_output_____" ] ], [ [ "df1['date'] = pd.to_datetime( df1['date'] )\ndf1.dtypes", "_____no_output_____" ] ], [ [ "## 1.4. Check NA", "_____no_output_____" ] ], [ [ "df1.isna().sum()", "_____no_output_____" ] ], [ [ "## 1.5. Fillout NA", "_____no_output_____" ] ], [ [ "df1.sample()", "_____no_output_____" ], [ "#competition_distance \ndf1['competition_distance'] = df1['competition_distance'].apply( lambda x: 200000.0 if math.isnan( x ) else x )\n\n#competition_open_since_month\ndf1['competition_open_since_month'] = df1.apply( lambda x: x['date'].month if math.isnan( x['competition_open_since_month'] ) else x['competition_open_since_month'], axis=1 )\n\n#competition_open_since_year \ndf1['competition_open_since_year'] = df1.apply( lambda x: x['date'].year if math.isnan( x['competition_open_since_year'] ) else x['competition_open_since_year'], axis=1 )\n\n#promo2_since_week \ndf1['promo2_since_week'] = df1.apply( lambda x: x['date'].week if math.isnan( x['promo2_since_week'] ) else x['promo2_since_week'], axis=1 )\n\n#promo2_since_year \ndf1['promo2_since_year'] = df1.apply( lambda x: x['date'].year if math.isnan( x['promo2_since_year'] ) else x['promo2_since_year'], axis=1 )\n\n#promo_interval \nmonth_map = {1: 'Jan', 2: 'Fev', 3: 'Mar', 4: 'Apr', 5: 'May', 6: 'Jun', 7: 'Jul', 8: 'Aug', 9: 'Sep', 10: 'Oct', 11: 'Nov', 12: 'Dec'}\n\ndf1['promo_interval'].fillna(0, inplace=True )\n\ndf1['month_map'] = df1['date'].dt.month.map( month_map )\n\ndf1['is_promo'] = df1[['promo_interval', 'month_map']].apply( lambda x: 0 if x['promo_interval'] == 0 else 1 if x['month_map'] in x['promo_interval'].split( ',' ) else 0, axis=1 )\n", "_____no_output_____" ], [ "df1.isna().sum()", "_____no_output_____" ] ], [ [ "## 1.6. Change Data Types", "_____no_output_____" ] ], [ [ "# competiton\ndf1['competition_open_since_month'] = df1['competition_open_since_month'].astype( int )\ndf1['competition_open_since_year'] = df1['competition_open_since_year'].astype( int )\n \n# promo2\ndf1['promo2_since_week'] = df1['promo2_since_week'].astype( int )\ndf1['promo2_since_year'] = df1['promo2_since_year'].astype( int )", "_____no_output_____" ] ], [ [ "## 1.7. Descriptive Statistics", "_____no_output_____" ] ], [ [ "num_attributes = df1.select_dtypes( include=['int64', 'float64'] )\ncat_attributes = df1.select_dtypes( exclude=['int64', 'float64', 'datetime64[ns]'] )", "_____no_output_____" ] ], [ [ "### 1.7.1. Numerical Atributes", "_____no_output_____" ] ], [ [ "# Central Tendency - mean, meadina \nct1 = pd.DataFrame( num_attributes.apply( np.mean ) ).T\nct2 = pd.DataFrame( num_attributes.apply( np.median ) ).T\n\n# dispersion - std, min, max, range, skew, kurtosis\nd1 = pd.DataFrame( num_attributes.apply( np.std ) ).T \nd2 = pd.DataFrame( num_attributes.apply( min ) ).T \nd3 = pd.DataFrame( num_attributes.apply( max ) ).T \nd4 = pd.DataFrame( num_attributes.apply( lambda x: x.max() - x.min() ) ).T \nd5 = pd.DataFrame( num_attributes.apply( lambda x: x.skew() ) ).T \nd6 = pd.DataFrame( num_attributes.apply( lambda x: x.kurtosis() ) ).T \n\n# concatenar\nm = pd.concat( [d2, d3, d4, ct1, ct2, d1, d5, d6] ).T.reset_index()\nm.columns = ['attributes', 'min', 'max', 'range', 'mean', 'median', 'std', 'skew', 'kurtosis']\nm", "_____no_output_____" ], [ "sns.distplot( df1['competition_distance'], kde=False )", "_____no_output_____" ] ], [ [ "### 1.7.2. Categorical Atributes", "_____no_output_____" ] ], [ [ "cat_attributes.apply( lambda x: x.unique().shape[0] )", "_____no_output_____" ], [ "aux = df1[(df1['state_holiday'] != '0') & (df1['sales'] > 0)]\n\nplt.subplot( 1, 3, 1 )\nsns.boxplot( x='state_holiday', y='sales', data=aux )\n\nplt.subplot( 1, 3, 2 )\nsns.boxplot( x='store_type', y='sales', data=aux )\n\nplt.subplot( 1, 3, 3 )\nsns.boxplot( x='assortment', y='sales', data=aux )", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Chapter 8: Modeling Continuous Variables", "_____no_output_____" ] ], [ [ "import swat\n\nconn = swat.CAS('server-name.mycomany.com', 5570, 'username', 'password')", "_____no_output_____" ], [ "cars = conn.upload_file('https://raw.githubusercontent.com/sassoftware/sas-viya-programming/master/data/cars.csv',\n casout=dict(name='cars', replace=True))", "NOTE: Cloud Analytic Services made the uploaded file available as table CARS in caslib CASUSER(username).\nNOTE: The table CARS has been created in caslib CASUSER(username) from binary data uploaded to Cloud Analytic Services.\n" ], [ "cars.tableinfo()", "_____no_output_____" ], [ "cars.columninfo()", "_____no_output_____" ] ], [ [ "## Linear Regressions", "_____no_output_____" ] ], [ [ "conn.loadactionset('regression')\nconn.help(actionset='regression')", "NOTE: Added action set 'regression'.\nNOTE: Information for action set 'regression':\nNOTE: regression\nNOTE: glm - Fits linear regression models using the method of least squares\nNOTE: genmod - Fits generalized linear regression models\nNOTE: logistic - Fits logistic regression models\n" ] ], [ [ "Simple linear regression", "_____no_output_____" ] ], [ [ "cars.glm( \n target='MSRP',\n inputs=['MPG_City']\n)", "_____no_output_____" ] ], [ [ "Another way to define a model ", "_____no_output_____" ] ], [ [ "linear1 = cars.Glm()\nlinear1.target = 'MSRP'\nlinear1.inputs = ['MPG_City']\nlinear1()", "_____no_output_____" ], [ "linear1.display.names = ['ParameterEstimates']\nlinear1()", "_____no_output_____" ] ], [ [ "Scoring", "_____no_output_____" ] ], [ [ "del linear1.display.names\n\nresult1 = conn.CASTable('MSRPPrediction')\nresult1.replace = True\nlinear1.output.casout = result1\nlinear1.output.copyVars = 'ALL';\nlinear1()", "_____no_output_____" ], [ "result1[['pred']].summary()", "_____no_output_____" ] ], [ [ "Output more information in the score table", "_____no_output_____" ] ], [ [ "result2 = conn.CASTable('MSRPPrediction3')\nresult2.replace = True\nlinear1.output.casout = result2\nlinear1.output.pred = 'Predicted_MSRP'\nlinear1.output.resid = 'Presidual_MSRP'\nlinear1.output.lcl = 'LCL_MSRP'\nlinear1.output.ucl = 'UCL_MSRP'\nlinear1()", "_____no_output_____" ] ], [ [ "Use scatter plot of predicted values and residuals to check the model fitting", "_____no_output_____" ] ], [ [ "from bokeh.charts import Scatter, output_file, output_notebook, show\n\nout1 = result2.to_frame()\n\np = Scatter(out1, x='Predicted_MSRP', y='Residual_MSRP', color='Origin', marker='Origin')\noutput_notebook()\n#output_file('scatter.html')\nshow(p)", "_____no_output_____" ] ], [ [ "Investigate which observations have negative predicted MSRP values", "_____no_output_____" ] ], [ [ "result2[['Predicted_MSRP', 'MSRP', 'MPG_City','Make','Model']].query('Predicted_MSRP < 0').to_frame()", "_____no_output_____" ], [ "p = Scatter(out1, x='MPG_City', y='MSRP', color='Origin', marker='Origin')\noutput_notebook()\n#output_file('scatter.html')\nshow(p)", "_____no_output_____" ] ], [ [ "Remove outliers", "_____no_output_____" ] ], [ [ "cars.where = 'MSRP < 100000 and MPG_City < 40'\n\nresult2 = conn.CASTable('cas.MSRPPrediction2')\nresult2.replace = True\n\nlinear2 = cars.Glm()\nlinear2 = cars.query('MSRP < 100000 and MPG_City < 40').glm\nlinear2.target = 'MSRP'\nlinear2.inputs = ['MPG_City']\nlinear2.output.casout = result2\nlinear2.output.copyVars = 'ALL';\nlinear2.output.pred = 'Predicted_MSRP'\nlinear2.output.resid = 'Residual_MSRP'\nlinear2.output.lcl = 'LCL_MSRP'\nlinear2.output.ucl = 'UCL_MSRP'\nlinear2()", "_____no_output_____" ] ], [ [ "Check the model fitting again", "_____no_output_____" ] ], [ [ "out2 = result2.to_frame()\np = Scatter(out2, x='Predicted_MSRP', y='Residual_MSRP', color='Origin', marker='Origin')\noutput_notebook()\n#output_file('scatter.html')\nshow(p)", "_____no_output_____" ] ], [ [ "Adding more predictors", "_____no_output_____" ] ], [ [ "nomList = ['Origin','Type','DriveTrain']\ncontList = ['MPG_City','Weight','Length']\n\nlinear3 = conn.CASTable('cars').Glm()\nlinear3.target = 'MSRP'\nlinear3.inputs = nomList + contList\nlinear3.nominals = nomList\nlinear3.display.names = ['FitStatistics','ParameterEstimates']\nlinear3()", "_____no_output_____" ] ], [ [ "Groupby regression ", "_____no_output_____" ] ], [ [ "cars = conn.CASTable('cars')\nout = cars.groupby('Origin')[['MSRP']].summary().concat_bygroups()\nout['Summary'][['Column','Mean','Var','Std']]", "_____no_output_____" ], [ "cars = conn.CASTable('cars')\ncars.groupby=['Origin']\ncars.where = 'MSRP < 100000 and MPG_City < 40'\nnomList = ['Type','DriveTrain']\ncontList = ['MPG_City','Weight','Length']\ngroupBYResult =conn.CASTable('MSRPPredictionGroupBy')\n\nlinear4 = cars.glm\nlinear4.target = 'MSRP'\nlinear4.inputs = nomList + contList\nlinear4.nominals = nomList\nlinear4.display.names = ['FitStatistics','ParameterEstimates']\nlinear4.output.casout = groupBYResult\nlinear4.output.copyVars = 'ALL';\nlinear4.output.pred = 'Predicted_MSRP'\nlinear4.output.resid = 'Residual_MSRP'\nlinear4.output.lcl = 'LCL_MSRP'\nlinear4.output.ucl = 'UCL_MSRP'\nlinear4()", "_____no_output_____" ], [ "out = groupBYResult.to_frame()\np = Scatter(out, x='Predicted_MSRP', y='Residual_MSRP', color='Origin', marker='Origin')\noutput_notebook()\n#output_file('scatter.html')\nshow(p)", "_____no_output_____" ] ], [ [ "## Extensions of Ordinary Linear Regression", "_____no_output_____" ], [ "### Generalized Linear Models", "_____no_output_____" ], [ "Gamma Regression", "_____no_output_____" ] ], [ [ "cars = conn.CASTable('cars')\ngenmodModel1 = cars.Genmod()\ngenmodModel1.model.depvars = 'MSRP'\ngenmodModel1.model.effects = ['MPG_City']\ngenmodModel1.model.dist = 'gamma'\ngenmodModel1.model.link = 'log'\ngenmodModel1()", "NOTE: Convergence criterion (GCONV=1E-8) satisfied.\n" ] ], [ [ "Multinomial Regression", "_____no_output_____" ] ], [ [ "genmodModel1.model.depvars = 'Cylinders'\ngenmodModel1.model.dist = 'multinomial'\ngenmodModel1.model.link = 'logit'\ngenmodModel1.model.effects = ['MPG_City']\ngenmodModel1.display.names = ['ModelInfo', 'ParameterEstimates']\ngenmodModel1()", "NOTE: Convergence criterion (GCONV=1E-8) satisfied.\n" ] ], [ [ "Score the input table", "_____no_output_____" ] ], [ [ "genmodResult = conn.CASTable('CylinderPredicted', replace=True)\ngenmodModel1.output.casout = genmodResult\ngenmodModel1.output.copyVars = 'ALL';\ngenmodModel1.output.pred = 'Prob_Cylinders'\ngenmodModel1()\ngenmodResult[['Prob_Cylinders','_level_','Cylinders','MPG_City']].head(24)", "NOTE: Convergence criterion (GCONV=1E-8) satisfied.\n" ] ], [ [ "### Regression Trees", "_____no_output_____" ] ], [ [ "conn.loadactionset('decisiontree')\nconn.help(actionset='decisiontree')", "NOTE: Added action set 'decisiontree'.\nNOTE: Information for action set 'decisiontree':\nNOTE: decisionTree\nNOTE: dtreeTrain - Train a decision tree\nNOTE: dtreeScore - Score a table using a decision tree model\nNOTE: dtreeSplit - Split decision tree nodes\nNOTE: dtreePrune - Prune a decision tree\nNOTE: dtreeMerge - Merge decision tree nodes\nNOTE: dtreeCode - Generate DATA step scoring code from a decision tree model\nNOTE: forestTrain - Train a forest\nNOTE: forestScore - Score a table using a forest model\nNOTE: forestCode - Generate DATA step scoring code from a forest model\nNOTE: gbtreeTrain - Train a gradient boosting tree\nNOTE: gbtreeScore - Score a table using a gradient boosting tree model\nNOTE: gbtreecode - Generate DATA step scoring code from a gradient boosting tree model\n" ], [ "cars = conn.CASTable('cars')\n\noutput1 = conn.CASTable('treeModel1')\noutput1.replace = True;\n\ntree1 = cars.dtreetrain\ntree1.target = 'MSRP'\ntree1.inputs = ['MPG_City']\ntree1.casout = output1\ntree1.maxlevel = 2\ntree1()", "_____no_output_____" ], [ "output1[['_NodeID_', '_Parent_','_Mean_','_NodeName_','_PBLower0_','_PBUpper0_']].fetch()", "_____no_output_____" ], [ "conn.close()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Huggingface Sagemaker-sdk - Distributed Training Demo for `TensorFlow`\n### Distributed Data Parallelism with `transformers` and `tensorflow`", "_____no_output_____" ], [ "1. [Introduction](#Introduction) \n2. [Development Environment and Permissions](#Development-Environment-and-Permissions)\n 1. [Installation](#Installation) \n 2. [Development environment](#Development-environment) \n 3. [Permissions](#Permissions)\n3. [Processing](#Preprocessing) \n 1. [Tokenization](#Tokenization) \n 2. [Uploading data to sagemaker_session_bucket](#Uploading-data-to-sagemaker_session_bucket) \n4. [Fine-tuning & starting Sagemaker Training Job](#Fine-tuning-\\&-starting-Sagemaker-Training-Job) \n 1. [Creating an Estimator and start a training job](#Creating-an-Estimator-and-start-a-training-job) \n 2. [Estimator Parameters](#Estimator-Parameters) \n 3. [Download fine-tuned model from s3](#Download-fine-tuned-model-from-s3)\n 3. [Attach to old training job to an estimator ](#Attach-to-old-training-job-to-an-estimator) \n5. [_Coming soon_:Push model to the Hugging Face hub](#Push-model-to-the-Hugging-Face-hub)", "_____no_output_____" ], [ "# Introduction\n\nWelcome to our distributed end-to-end binary Text-Classification example. In this demo, we will use the Hugging Faces `transformers` and `datasets` library together with a custom Amazon sagemaker-sdk extension to fine-tune a pre-trained transformer on binary text classification. In particular, the pre-trained model will be fine-tuned using the `imdb` dataset. To speed upload Training we are going to use SageMaker distributed Data Parallel library to run our training distributed across multiple gpus. To get started, we need to set up the environment with a few prerequisite steps, for permissions, configurations, and so on. \n\n\n\n_**NOTE: You can run this demo in Sagemaker Studio, your local machine or Sagemaker Notebook Instances**_", "_____no_output_____" ], [ "# Development Environment and Permissions ", "_____no_output_____" ], [ "## Installation\n\n_*Note:* we only install the required libraries from Hugging Face and AWS. You also need PyTorch or Tensorflow, if you haven´t it installed_", "_____no_output_____" ] ], [ [ "!pip install \"sagemaker>=2.48.0\" --upgrade", "_____no_output_____" ] ], [ [ "## Development environment ", "_____no_output_____" ], [ "**upgrade ipywidgets for `datasets` library and restart kernel, only needed when prerpocessing is done in the notebook**", "_____no_output_____" ] ], [ [ "%%capture\nimport IPython\n!conda install -c conda-forge ipywidgets -y\nIPython.Application.instance().kernel.do_shutdown(True) # has to restart kernel so changes are used", "_____no_output_____" ], [ "import sagemaker.huggingface", "_____no_output_____" ] ], [ [ "## Permissions", "_____no_output_____" ], [ "_If you are going to use Sagemaker in a local environment. You need access to an IAM Role with the required permissions for Sagemaker. You can find [here](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) more about it._", "_____no_output_____" ] ], [ [ "import sagemaker\n\nsess = sagemaker.Session()\n# sagemaker session bucket -> used for uploading data, models and logs\n# sagemaker will automatically create this bucket if it not exists\nsagemaker_session_bucket=None\nif sagemaker_session_bucket is None and sess is not None:\n # set to default bucket if a bucket name is not given\n sagemaker_session_bucket = sess.default_bucket()\n\nrole = sagemaker.get_execution_role()\nsess = sagemaker.Session(default_bucket=sagemaker_session_bucket)\n\nprint(f\"sagemaker role arn: {role}\")\nprint(f\"sagemaker bucket: {sess.default_bucket()}\")\nprint(f\"sagemaker session region: {sess.boto_region_name}\")", "_____no_output_____" ] ], [ [ "# Preprocessing\n\nIn this example the preproccsing will be done in the `train.py` when executing the script. You could also move the `preprocessing` outside of the script and upload the data to s3 and pass it into it.", "_____no_output_____" ], [ "# Fine-tuning & starting Sagemaker Training Job\n\nIn order to create a sagemaker training job we need an `HuggingFace` Estimator. The Estimator handles end-to-end Amazon SageMaker training and deployment tasks. In a Estimator we define, which fine-tuning script should be used as `entry_point`, which `instance_type` should be used, which `hyperparameters` are passed in .....\n\n\n\n```python\nhuggingface_estimator = HuggingFace(entry_point='train.py',\n source_dir='./scripts',\n base_job_name='huggingface-sdk-extension',\n instance_type='ml.p3.2xlarge',\n instance_count=1,\n transformers_version='4.4',\n pytorch_version='1.6',\n py_version='py37',\n role=role,\n hyperparameters = {'epochs': 1,\n 'train_batch_size': 32,\n 'model_name':'distilbert-base-uncased'\n })\n```\n\nWhen we create a SageMaker training job, SageMaker takes care of starting and managing all the required ec2 instances for us with the `huggingface` container, uploads the provided fine-tuning script `train.py` and downloads the data from our `sagemaker_session_bucket` into the container at `/opt/ml/input/data`. Then, it starts the training job by running. \n\n```python\n/opt/conda/bin/python train.py --epochs 1 --model_name distilbert-base-uncased --train_batch_size 32\n```\n\nThe `hyperparameters` you define in the `HuggingFace` estimator are passed in as named arguments. \n\nSagemaker is providing useful properties about the training environment through various environment variables, including the following:\n\n* `SM_MODEL_DIR`: A string that represents the path where the training job writes the model artifacts to. After training, artifacts in this directory are uploaded to S3 for model hosting.\n\n* `SM_NUM_GPUS`: An integer representing the number of GPUs available to the host.\n\n* `SM_CHANNEL_XXXX:` A string that represents the path to the directory that contains the input data for the specified channel. For example, if you specify two input channels in the HuggingFace estimator’s fit call, named `train` and `test`, the environment variables `SM_CHANNEL_TRAIN` and `SM_CHANNEL_TEST` are set.\n\n\nTo run your training job locally you can define `instance_type='local'` or `instance_type='local_gpu'` for gpu usage. _Note: this does not working within SageMaker Studio_\n", "_____no_output_____" ] ], [ [ "!pygmentize ./scripts/train.py", "\u001b[34mimport\u001b[39;49;00m \u001b[04m\u001b[36margparse\u001b[39;49;00m\r\n\u001b[34mimport\u001b[39;49;00m \u001b[04m\u001b[36mlogging\u001b[39;49;00m\r\n\u001b[34mimport\u001b[39;49;00m \u001b[04m\u001b[36mos\u001b[39;49;00m\r\n\u001b[34mimport\u001b[39;49;00m \u001b[04m\u001b[36msys\u001b[39;49;00m\r\n\r\n\u001b[34mimport\u001b[39;49;00m \u001b[04m\u001b[36mtensorflow\u001b[39;49;00m \u001b[34mas\u001b[39;49;00m \u001b[04m\u001b[36mtf\u001b[39;49;00m\r\n\u001b[34mfrom\u001b[39;49;00m \u001b[04m\u001b[36mdatasets\u001b[39;49;00m \u001b[34mimport\u001b[39;49;00m load_dataset\r\n\u001b[34mfrom\u001b[39;49;00m \u001b[04m\u001b[36mtqdm\u001b[39;49;00m \u001b[34mimport\u001b[39;49;00m tqdm\r\n\u001b[34mfrom\u001b[39;49;00m \u001b[04m\u001b[36mtransformers\u001b[39;49;00m \u001b[34mimport\u001b[39;49;00m AutoTokenizer, TFAutoModelForSequenceClassification\r\n\u001b[34mfrom\u001b[39;49;00m \u001b[04m\u001b[36mtransformers\u001b[39;49;00m\u001b[04m\u001b[36m.\u001b[39;49;00m\u001b[04m\u001b[36mfile_utils\u001b[39;49;00m \u001b[34mimport\u001b[39;49;00m is_sagemaker_distributed_available\r\n\r\n\u001b[34mif\u001b[39;49;00m os.environ.get(\u001b[33m\"\u001b[39;49;00m\u001b[33mSDP_ENABLED\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m) \u001b[35mor\u001b[39;49;00m is_sagemaker_distributed_available():\r\n SDP_ENABLED = \u001b[34mTrue\u001b[39;49;00m\r\n os.environ[\u001b[33m\"\u001b[39;49;00m\u001b[33mSAGEMAKER_INSTANCE_TYPE\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m] = \u001b[33m\"\u001b[39;49;00m\u001b[33mp3dn.24xlarge\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\r\n \u001b[34mimport\u001b[39;49;00m \u001b[04m\u001b[36msmdistributed\u001b[39;49;00m\u001b[04m\u001b[36m.\u001b[39;49;00m\u001b[04m\u001b[36mdataparallel\u001b[39;49;00m\u001b[04m\u001b[36m.\u001b[39;49;00m\u001b[04m\u001b[36mtensorflow\u001b[39;49;00m \u001b[34mas\u001b[39;49;00m \u001b[04m\u001b[36msdp\u001b[39;49;00m\r\n\u001b[34melse\u001b[39;49;00m:\r\n SDP_ENABLED = \u001b[34mFalse\u001b[39;49;00m\r\n\r\n\r\n\u001b[34mdef\u001b[39;49;00m \u001b[32mfit\u001b[39;49;00m(model, loss, opt, train_dataset, epochs, train_batch_size, max_steps=\u001b[34mNone\u001b[39;49;00m):\r\n pbar = tqdm(train_dataset)\r\n \u001b[34mfor\u001b[39;49;00m i, batch \u001b[35min\u001b[39;49;00m \u001b[36menumerate\u001b[39;49;00m(pbar):\r\n \u001b[34mwith\u001b[39;49;00m tf.GradientTape() \u001b[34mas\u001b[39;49;00m tape:\r\n inputs, targets = batch\r\n outputs = model(batch)\r\n loss_value = loss(targets, outputs.logits)\r\n\r\n \u001b[34mif\u001b[39;49;00m SDP_ENABLED:\r\n tape = sdp.DistributedGradientTape(tape, sparse_as_dense=\u001b[34mTrue\u001b[39;49;00m)\r\n\r\n grads = tape.gradient(loss_value, model.trainable_variables)\r\n opt.apply_gradients(\u001b[36mzip\u001b[39;49;00m(grads, model.trainable_variables))\r\n\r\n pbar.set_description(\u001b[33mf\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[33mLoss: \u001b[39;49;00m\u001b[33m{\u001b[39;49;00mloss_value\u001b[33m:\u001b[39;49;00m\u001b[33m.4f\u001b[39;49;00m\u001b[33m}\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n\r\n \u001b[34mif\u001b[39;49;00m SDP_ENABLED:\r\n \u001b[34mif\u001b[39;49;00m i == \u001b[34m0\u001b[39;49;00m:\r\n sdp.broadcast_variables(model.variables, root_rank=\u001b[34m0\u001b[39;49;00m)\r\n sdp.broadcast_variables(opt.variables(), root_rank=\u001b[34m0\u001b[39;49;00m)\r\n first_batch = \u001b[34mFalse\u001b[39;49;00m\r\n\r\n \u001b[34mif\u001b[39;49;00m max_steps \u001b[35mand\u001b[39;49;00m i >= max_steps:\r\n \u001b[34mbreak\u001b[39;49;00m\r\n\r\n train_results = {\u001b[33m\"\u001b[39;49;00m\u001b[33mloss\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m: loss_value.numpy()}\r\n \u001b[34mreturn\u001b[39;49;00m train_results\r\n\r\n\r\n\u001b[34mdef\u001b[39;49;00m \u001b[32mget_datasets\u001b[39;49;00m():\r\n \u001b[37m# Load dataset\u001b[39;49;00m\r\n train_dataset, test_dataset = load_dataset(\u001b[33m\"\u001b[39;49;00m\u001b[33mimdb\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, split=[\u001b[33m\"\u001b[39;49;00m\u001b[33mtrain\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mtest\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m])\r\n\r\n \u001b[37m# Preprocess train dataset\u001b[39;49;00m\r\n train_dataset = train_dataset.map(\r\n \u001b[34mlambda\u001b[39;49;00m e: tokenizer(e[\u001b[33m\"\u001b[39;49;00m\u001b[33mtext\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m], truncation=\u001b[34mTrue\u001b[39;49;00m, padding=\u001b[33m\"\u001b[39;49;00m\u001b[33mmax_length\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m), batched=\u001b[34mTrue\u001b[39;49;00m\r\n )\r\n train_dataset.set_format(\u001b[36mtype\u001b[39;49;00m=\u001b[33m\"\u001b[39;49;00m\u001b[33mtensorflow\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, columns=[\u001b[33m\"\u001b[39;49;00m\u001b[33minput_ids\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mattention_mask\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mlabel\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m])\r\n\r\n train_features = {\r\n x: train_dataset[x].to_tensor(default_value=\u001b[34m0\u001b[39;49;00m, shape=[\u001b[34mNone\u001b[39;49;00m, tokenizer.model_max_length])\r\n \u001b[34mfor\u001b[39;49;00m x \u001b[35min\u001b[39;49;00m [\u001b[33m\"\u001b[39;49;00m\u001b[33minput_ids\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mattention_mask\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\r\n }\r\n tf_train_dataset = tf.data.Dataset.from_tensor_slices((train_features, train_dataset[\u001b[33m\"\u001b[39;49;00m\u001b[33mlabel\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]))\r\n\r\n \u001b[37m# Preprocess test dataset\u001b[39;49;00m\r\n test_dataset = test_dataset.map(\r\n \u001b[34mlambda\u001b[39;49;00m e: tokenizer(e[\u001b[33m\"\u001b[39;49;00m\u001b[33mtext\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m], truncation=\u001b[34mTrue\u001b[39;49;00m, padding=\u001b[33m\"\u001b[39;49;00m\u001b[33mmax_length\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m), batched=\u001b[34mTrue\u001b[39;49;00m\r\n )\r\n test_dataset.set_format(\u001b[36mtype\u001b[39;49;00m=\u001b[33m\"\u001b[39;49;00m\u001b[33mtensorflow\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, columns=[\u001b[33m\"\u001b[39;49;00m\u001b[33minput_ids\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mattention_mask\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mlabel\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m])\r\n\r\n test_features = {\r\n x: test_dataset[x].to_tensor(default_value=\u001b[34m0\u001b[39;49;00m, shape=[\u001b[34mNone\u001b[39;49;00m, tokenizer.model_max_length])\r\n \u001b[34mfor\u001b[39;49;00m x \u001b[35min\u001b[39;49;00m [\u001b[33m\"\u001b[39;49;00m\u001b[33minput_ids\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[33m\"\u001b[39;49;00m\u001b[33mattention_mask\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]\r\n }\r\n tf_test_dataset = tf.data.Dataset.from_tensor_slices((test_features, test_dataset[\u001b[33m\"\u001b[39;49;00m\u001b[33mlabel\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m]))\r\n\r\n \u001b[34mif\u001b[39;49;00m SDP_ENABLED:\r\n tf_train_dataset = tf_train_dataset.shard(sdp.size(), sdp.rank())\r\n tf_test_dataset = tf_test_dataset.shard(sdp.size(), sdp.rank())\r\n tf_train_dataset = tf_train_dataset.batch(args.train_batch_size, drop_remainder=\u001b[34mTrue\u001b[39;49;00m)\r\n tf_test_dataset = tf_test_dataset.batch(args.eval_batch_size, drop_remainder=\u001b[34mTrue\u001b[39;49;00m)\r\n\r\n \u001b[34mreturn\u001b[39;49;00m tf_train_dataset, tf_test_dataset\r\n\r\n\r\n\u001b[34mif\u001b[39;49;00m \u001b[31m__name__\u001b[39;49;00m == \u001b[33m\"\u001b[39;49;00m\u001b[33m__main__\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m:\r\n\r\n parser = argparse.ArgumentParser()\r\n\r\n \u001b[37m# Hyperparameters sent by the client are passed as command-line arguments to the script.\u001b[39;49;00m\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--epochs\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mint\u001b[39;49;00m, default=\u001b[34m3\u001b[39;49;00m)\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--train-batch-size\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mint\u001b[39;49;00m, default=\u001b[34m16\u001b[39;49;00m)\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--eval-batch-size\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mint\u001b[39;49;00m, default=\u001b[34m8\u001b[39;49;00m)\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--model_name\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mstr\u001b[39;49;00m)\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--learning_rate\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mstr\u001b[39;49;00m, default=\u001b[34m5e-5\u001b[39;49;00m)\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--do_train\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mbool\u001b[39;49;00m, default=\u001b[34mTrue\u001b[39;49;00m)\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--do_eval\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mbool\u001b[39;49;00m, default=\u001b[34mTrue\u001b[39;49;00m)\r\n\r\n \u001b[37m# Data, model, and output directories\u001b[39;49;00m\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--output_data_dir\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mstr\u001b[39;49;00m, default=os.environ[\u001b[33m\"\u001b[39;49;00m\u001b[33mSM_OUTPUT_DATA_DIR\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m])\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--model_dir\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mstr\u001b[39;49;00m, default=os.environ[\u001b[33m\"\u001b[39;49;00m\u001b[33mSM_MODEL_DIR\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m])\r\n parser.add_argument(\u001b[33m\"\u001b[39;49;00m\u001b[33m--n_gpus\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, \u001b[36mtype\u001b[39;49;00m=\u001b[36mstr\u001b[39;49;00m, default=os.environ[\u001b[33m\"\u001b[39;49;00m\u001b[33mSM_NUM_GPUS\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m])\r\n\r\n args, _ = parser.parse_known_args()\r\n\r\n \u001b[37m# Set up logging\u001b[39;49;00m\r\n logger = logging.getLogger(\u001b[31m__name__\u001b[39;49;00m)\r\n\r\n logging.basicConfig(\r\n level=logging.getLevelName(\u001b[33m\"\u001b[39;49;00m\u001b[33mINFO\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m),\r\n handlers=[logging.StreamHandler(sys.stdout)],\r\n \u001b[36mformat\u001b[39;49;00m=\u001b[33m\"\u001b[39;49;00m\u001b[33m%(asctime)s\u001b[39;49;00m\u001b[33m - \u001b[39;49;00m\u001b[33m%(name)s\u001b[39;49;00m\u001b[33m - \u001b[39;49;00m\u001b[33m%(levelname)s\u001b[39;49;00m\u001b[33m - \u001b[39;49;00m\u001b[33m%(message)s\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m,\r\n )\r\n\r\n \u001b[34mif\u001b[39;49;00m SDP_ENABLED:\r\n sdp.init()\r\n\r\n gpus = tf.config.experimental.list_physical_devices(\u001b[33m\"\u001b[39;49;00m\u001b[33mGPU\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n \u001b[34mfor\u001b[39;49;00m gpu \u001b[35min\u001b[39;49;00m gpus:\r\n tf.config.experimental.set_memory_growth(gpu, \u001b[34mTrue\u001b[39;49;00m)\r\n \u001b[34mif\u001b[39;49;00m gpus:\r\n tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], \u001b[33m\"\u001b[39;49;00m\u001b[33mGPU\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n\r\n \u001b[37m# Load model and tokenizer\u001b[39;49;00m\r\n model = TFAutoModelForSequenceClassification.from_pretrained(args.model_name)\r\n tokenizer = AutoTokenizer.from_pretrained(args.model_name)\r\n\r\n \u001b[37m# get datasets\u001b[39;49;00m\r\n tf_train_dataset, tf_test_dataset = get_datasets()\r\n\r\n \u001b[37m# fine optimizer and loss\u001b[39;49;00m\r\n optimizer = tf.keras.optimizers.Adam(learning_rate=args.learning_rate)\r\n loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=\u001b[34mTrue\u001b[39;49;00m)\r\n metrics = [tf.keras.metrics.SparseCategoricalAccuracy()]\r\n model.compile(optimizer=optimizer, loss=loss, metrics=metrics)\r\n\r\n \u001b[37m# Training\u001b[39;49;00m\r\n \u001b[34mif\u001b[39;49;00m args.do_train:\r\n\r\n \u001b[37m# train_results = model.fit(tf_train_dataset, epochs=args.epochs, batch_size=args.train_batch_size)\u001b[39;49;00m\r\n train_results = fit(\r\n model, loss, optimizer, tf_train_dataset, args.epochs, args.train_batch_size, max_steps=\u001b[34mNone\u001b[39;49;00m\r\n )\r\n logger.info(\u001b[33m\"\u001b[39;49;00m\u001b[33m*** Train ***\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n\r\n output_eval_file = os.path.join(args.output_data_dir, \u001b[33m\"\u001b[39;49;00m\u001b[33mtrain_results.txt\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n\r\n \u001b[34mif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m SDP_ENABLED \u001b[35mor\u001b[39;49;00m sdp.rank() == \u001b[34m0\u001b[39;49;00m:\r\n \u001b[34mwith\u001b[39;49;00m \u001b[36mopen\u001b[39;49;00m(output_eval_file, \u001b[33m\"\u001b[39;49;00m\u001b[33mw\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m) \u001b[34mas\u001b[39;49;00m writer:\r\n logger.info(\u001b[33m\"\u001b[39;49;00m\u001b[33m***** Train results *****\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n logger.info(train_results)\r\n \u001b[34mfor\u001b[39;49;00m key, value \u001b[35min\u001b[39;49;00m train_results.items():\r\n logger.info(\u001b[33m\"\u001b[39;49;00m\u001b[33m \u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m = \u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, key, value)\r\n writer.write(\u001b[33m\"\u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m = \u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m\\n\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m % (key, value))\r\n\r\n \u001b[37m# Evaluation\u001b[39;49;00m\r\n \u001b[34mif\u001b[39;49;00m args.do_eval \u001b[35mand\u001b[39;49;00m (\u001b[35mnot\u001b[39;49;00m SDP_ENABLED \u001b[35mor\u001b[39;49;00m sdp.rank() == \u001b[34m0\u001b[39;49;00m):\r\n\r\n result = model.evaluate(tf_test_dataset, batch_size=args.eval_batch_size, return_dict=\u001b[34mTrue\u001b[39;49;00m)\r\n logger.info(\u001b[33m\"\u001b[39;49;00m\u001b[33m*** Evaluate ***\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n\r\n output_eval_file = os.path.join(args.output_data_dir, \u001b[33m\"\u001b[39;49;00m\u001b[33meval_results.txt\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n\r\n \u001b[34mwith\u001b[39;49;00m \u001b[36mopen\u001b[39;49;00m(output_eval_file, \u001b[33m\"\u001b[39;49;00m\u001b[33mw\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m) \u001b[34mas\u001b[39;49;00m writer:\r\n logger.info(\u001b[33m\"\u001b[39;49;00m\u001b[33m***** Eval results *****\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m)\r\n logger.info(result)\r\n \u001b[34mfor\u001b[39;49;00m key, value \u001b[35min\u001b[39;49;00m result.items():\r\n logger.info(\u001b[33m\"\u001b[39;49;00m\u001b[33m \u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m = \u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m, key, value)\r\n writer.write(\u001b[33m\"\u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m = \u001b[39;49;00m\u001b[33m%s\u001b[39;49;00m\u001b[33m\\n\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m % (key, value))\r\n\r\n \u001b[37m# Save result\u001b[39;49;00m\r\n \u001b[34mif\u001b[39;49;00m SDP_ENABLED:\r\n \u001b[34mif\u001b[39;49;00m sdp.rank() == \u001b[34m0\u001b[39;49;00m:\r\n model.save_pretrained(args.model_dir)\r\n tokenizer.save_pretrained(args.model_dir)\r\n \u001b[34melse\u001b[39;49;00m:\r\n model.save_pretrained(args.model_dir)\r\n tokenizer.save_pretrained(args.model_dir)\r\n" ] ], [ [ "## Creating an Estimator and start a training job", "_____no_output_____" ] ], [ [ "from sagemaker.huggingface import HuggingFace\n\n# hyperparameters, which are passed into the training job\nhyperparameters={\n 'epochs': 1,\n 'train_batch_size': 16,\n 'model_name':'distilbert-base-uncased',\n}\n\n# configuration for running training on smdistributed Data Parallel\ndistribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}\n\n# instance configurations\ninstance_type='ml.p3dn.24xlarge'\ninstance_count=2\nvolume_size=200", "nieljare-hf-tf24-droplast-nodebugger-3node-sdp\nLaunched job nieljare-hf-tf24-droplast-nodebugger-3node-sdp\n" ], [ "huggingface_estimator = HuggingFace(\n entry_point='train.py',\n source_dir='./scripts',\n instance_type=instance_type,\n instance_count=instance_count,\n role=role,\n transformers_version='4.6',\n tensorflow_version='2.4',\n py_version='py37',\n distribution=distribution,\n hyperparameters=hyperparameters,\n debugger_hook_config=False, # currently needed\n)", "_____no_output_____" ], [ "huggingface_estimator.fit()", "_____no_output_____" ] ], [ [ "## Deploying the endpoint\n\nTo deploy our endpoint, we call `deploy()` on our HuggingFace estimator object, passing in our desired number of instances and instance type.", "_____no_output_____" ] ], [ [ "predictor = huggingface_estimator.deploy(1,\"ml.g4dn.xlarge\")", "_____no_output_____" ] ], [ [ "Then, we use the returned predictor object to call the endpoint.", "_____no_output_____" ] ], [ [ "sentiment_input= {\"inputs\":\"I love using the new Inference DLC.\"}\n\npredictor.predict(sentiment_input)", "_____no_output_____" ] ], [ [ "Finally, we delete the endpoint again.", "_____no_output_____" ] ], [ [ "predictor.delete_endpoint()", "_____no_output_____" ] ], [ [ "# Extras", "_____no_output_____" ], [ "## Estimator Parameters", "_____no_output_____" ] ], [ [ "# container image used for training job\nprint(f\"container image used for training job: \\n{huggingface_estimator.image_uri}\\n\")\n\n# s3 uri where the trained model is located\nprint(f\"s3 uri where the trained model is located: \\n{huggingface_estimator.model_data}\\n\")\n\n# latest training job name for this estimator\nprint(f\"latest training job name for this estimator: \\n{huggingface_estimator.latest_training_job.name}\\n\")\n", "container image used for training job: \n763104351884.dkr.ecr.us-east-1.amazonaws.com/huggingface-tensorflow-training:2.4.1-transformers4.5.0-gpu-py37-cu110-ubuntu18.04\n\ns3 uri where the trained model is located: \ns3://sagemaker-us-east-1-558105141721/huggingface-training-2021-02-16-11-57-47-658/output/model.tar.gz\n\nlatest training job name for this estimator: \nhuggingface-training-2021-02-16-11-57-47-658\n\n" ], [ "# access the logs of the training job\nhuggingface_estimator.sagemaker_session.logs_for_job(huggingface_estimator.latest_training_job.name)", "_____no_output_____" ] ], [ [ "## Attach to old training job to an estimator \n\nIn Sagemaker you can attach an old training job to an estimator to continue training, get results etc..", "_____no_output_____" ] ], [ [ "from sagemaker.estimator import Estimator\n\n# job which is going to be attached to the estimator\nold_training_job_name=''", "_____no_output_____" ], [ "# attach old training job\nhuggingface_estimator_loaded = Estimator.attach(old_training_job_name)\n\n# get model output s3 from training job\nhuggingface_estimator_loaded.model_data", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport torchvision\nimport torchvision.transforms as transforms\nimport torchvision.datasets as datasets\n\nimport os\nimport random\nimport numpy as np", "_____no_output_____" ], [ "SEED = 1234\n\nrandom.seed(SEED)\nnp.random.seed(SEED)\ntorch.manual_seed(SEED)\ntorch.cuda.manual_seed(SEED)\ntorch.backends.cudnn.deterministic = True", "_____no_output_____" ], [ "train_transforms = transforms.Compose([\n transforms.RandomHorizontalFlip(),\n transforms.RandomRotation(10),\n transforms.RandomCrop((224, 224), pad_if_needed=True),\n transforms.ToTensor(),\n transforms.Normalize((0.485, 0.456, 0.406),(0.229, 0.224, 0.225))\n ])\n\ntest_transforms = transforms.Compose([\n transforms.CenterCrop((224, 224)),\n transforms.ToTensor(),\n transforms.Normalize((0.485, 0.456, 0.406),(0.229, 0.224, 0.225))\n ])", "_____no_output_____" ], [ "train_data = datasets.ImageFolder('data/dogs-vs-cats/train', train_transforms)\nvalid_data = datasets.ImageFolder('data/dogs-vs-cats/valid', test_transforms)\ntest_data = datasets.ImageFolder('data/dogs-vs-cats/test', test_transforms)\n\n#import os\n\n#print(len(os.listdir('data/dogs-vs-cats/train')))\n\n#n_train_examples = int(len(train_data)*0.9)\n#n_valid_examples = n_test_examples = len(train_data) - n_train_examples\n\n#train_data, valid_data = torch.utils.data.random_split(train_data, [n_train_examples, n_valid_examples])\n#train_data, test_data = torch.utils.data.random_split(train_data, [n_train_examples-n_valid_examples, n_test_examples])", "_____no_output_____" ] ], [ [ "https://github.com/facebook/fb.resnet.torch/issues/180\nhttps://github.com/bamos/densenet.pytorch/blob/master/compute-cifar10-mean.py", "_____no_output_____" ] ], [ [ "print(f'Number of training examples: {len(train_data)}')\nprint(f'Number of validation examples: {len(valid_data)}')\nprint(f'Number of testing examples: {len(test_data)}')", "Number of training examples: 20000\nNumber of validation examples: 2500\nNumber of testing examples: 2500\n" ], [ "BATCH_SIZE = 64\n\ntrain_iterator = torch.utils.data.DataLoader(train_data, shuffle=True, batch_size=BATCH_SIZE)\nvalid_iterator = torch.utils.data.DataLoader(valid_data, batch_size=BATCH_SIZE)\ntest_iterator = torch.utils.data.DataLoader(test_data, batch_size=BATCH_SIZE)", "_____no_output_____" ] ], [ [ "https://discuss.pytorch.org/t/why-does-the-resnet-model-given-by-pytorch-omit-biases-from-the-convolutional-layer/10990/4\nhttps://github.com/kuangliu/pytorch-cifar/blob/master/models/resnet.py", "_____no_output_____" ] ], [ [ "device = torch.device('cuda')", "_____no_output_____" ], [ "import torchvision.models as models\n\nmodel = models.resnet18(pretrained=True).to(device)", "_____no_output_____" ], [ "print(model)", "ResNet(\n (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n (layer1): Sequential(\n (0): BasicBlock(\n (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n (1): BasicBlock(\n (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n )\n (layer2): Sequential(\n (0): BasicBlock(\n (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (downsample): Sequential(\n (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n )\n (1): BasicBlock(\n (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n )\n (layer3): Sequential(\n (0): BasicBlock(\n (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (downsample): Sequential(\n (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n )\n (1): BasicBlock(\n (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n )\n (layer4): Sequential(\n (0): BasicBlock(\n (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (downsample): Sequential(\n (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n )\n (1): BasicBlock(\n (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n (relu): ReLU(inplace)\n (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n )\n )\n (avgpool): AvgPool2d(kernel_size=7, stride=1, padding=0)\n (fc): Linear(in_features=512, out_features=1000, bias=True)\n)\n" ], [ "for param in model.parameters():\n param.requires_grad = False", "_____no_output_____" ], [ "print(model.fc)", "Linear(in_features=512, out_features=1000, bias=True)\n" ], [ "model.fc = nn.Linear(in_features=512, out_features=2).to(device)", "_____no_output_____" ], [ "optimizer = optim.Adam(model.parameters())", "_____no_output_____" ], [ "criterion = nn.CrossEntropyLoss()", "_____no_output_____" ], [ "def calculate_accuracy(fx, y):\n preds = fx.max(1, keepdim=True)[1]\n correct = preds.eq(y.view_as(preds)).sum()\n acc = correct.float()/preds.shape[0]\n return acc", "_____no_output_____" ], [ "def train(model, device, iterator, optimizer, criterion):\n \n epoch_loss = 0\n epoch_acc = 0\n \n model.train()\n \n for (x, y) in iterator:\n \n x = x.to(device)\n y = y.to(device)\n \n optimizer.zero_grad()\n \n fx = model(x)\n \n loss = criterion(fx, y)\n \n acc = calculate_accuracy(fx, y)\n \n loss.backward()\n \n optimizer.step()\n \n epoch_loss += loss.item()\n epoch_acc += acc.item()\n \n return epoch_loss / len(iterator), epoch_acc / len(iterator)", "_____no_output_____" ], [ "def evaluate(model, device, iterator, criterion):\n \n epoch_loss = 0\n epoch_acc = 0\n \n model.eval()\n \n with torch.no_grad():\n for (x, y) in iterator:\n\n x = x.to(device)\n y = y.to(device)\n\n fx = model(x)\n\n loss = criterion(fx, y)\n\n acc = calculate_accuracy(fx, y)\n\n epoch_loss += loss.item()\n epoch_acc += acc.item()\n \n return epoch_loss / len(iterator), epoch_acc / len(iterator)", "_____no_output_____" ], [ "EPOCHS = 10\nSAVE_DIR = 'models'\nMODEL_SAVE_PATH = os.path.join(SAVE_DIR, 'resnet18-dogs-vs-cats.pt')\n\nbest_valid_loss = float('inf')\n\nif not os.path.isdir(f'{SAVE_DIR}'):\n os.makedirs(f'{SAVE_DIR}')\n\nfor epoch in range(EPOCHS):\n train_loss, train_acc = train(model, device, train_iterator, optimizer, criterion)\n valid_loss, valid_acc = evaluate(model, device, valid_iterator, criterion)\n \n if valid_loss < best_valid_loss:\n best_valid_loss = valid_loss\n torch.save(model.state_dict(), MODEL_SAVE_PATH)\n \n print(f'| Epoch: {epoch+1:02} | Train Loss: {train_loss:.3f} | Train Acc: {train_acc*100:05.2f}% | Val. Loss: {valid_loss:.3f} | Val. Acc: {valid_acc*100:05.2f}% |')", "| Epoch: 01 | Train Loss: 0.198 | Train Acc: 91.95% | Val. Loss: 0.089 | Val. Acc: 96.80% |\n| Epoch: 02 | Train Loss: 0.136 | Train Acc: 94.40% | Val. Loss: 0.069 | Val. Acc: 97.50% |\n| Epoch: 03 | Train Loss: 0.128 | Train Acc: 94.68% | Val. Loss: 0.059 | Val. Acc: 97.70% |\n| Epoch: 04 | Train Loss: 0.119 | Train Acc: 95.03% | Val. Loss: 0.070 | Val. Acc: 97.30% |\n| Epoch: 05 | Train Loss: 0.118 | Train Acc: 94.95% | Val. Loss: 0.057 | Val. Acc: 97.73% |\n| Epoch: 06 | Train Loss: 0.121 | Train Acc: 94.95% | Val. Loss: 0.056 | Val. Acc: 97.70% |\n| Epoch: 07 | Train Loss: 0.117 | Train Acc: 95.11% | Val. Loss: 0.063 | Val. Acc: 97.46% |\n| Epoch: 08 | Train Loss: 0.110 | Train Acc: 95.44% | Val. Loss: 0.052 | Val. Acc: 97.93% |\n| Epoch: 09 | Train Loss: 0.116 | Train Acc: 95.14% | Val. Loss: 0.056 | Val. Acc: 97.77% |\n| Epoch: 10 | Train Loss: 0.114 | Train Acc: 95.36% | Val. Loss: 0.063 | Val. Acc: 97.46% |\n" ], [ "model.load_state_dict(torch.load(MODEL_SAVE_PATH))\n\ntest_loss, test_acc = evaluate(model, device, valid_iterator, criterion)\n\nprint(f'| Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:05.2f}% |')", "| Test Loss: 0.052 | Test Acc: 97.93% |\n" ] ] ]

[ "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "Unlicense" ]

[ "Unlicense" ]

[ "Unlicense" ]

[ [ [ "import os \n\nos.environ[\"ISISROOT\"] = \"/usgs/cpkgs/anaconda3_linux/envs/isis3.7.0\"\n\nimport pysis\nfrom pysis import isis\nfrom pysis.exceptions import ProcessError\n\nimport knoten\nfrom knoten import vis\n\nimport json\n\nimport ale\nale.config['mex'] = '/home/acpaquette/5270/'\nfrom ale import util\nfrom ale.drivers.mex_drivers import MexHrscPds3NaifSpiceDriver\nfrom ale.formatters.usgscsm_formatter import to_usgscsm\n\nfrom IPython.display import Image\n\nimport plotly\nplotly.offline.init_notebook_mode(connected=True)", "_____no_output_____" ], [ "# url = 'https://pds-imaging.jpl.nasa.gov/data/mro/mars_reconnaissance_orbiter/ctx/mrox_3365/data/K11_057871_1602_XN_19S163W.IMG'\n\n# !wget -N -P data/ {url}\n# fileName = 'data/' + os.path.split(url)[1]\nfileName = '/home/acpaquette/5270/h5270_0000_nd2.img'\ncamera = knoten.csm.create_csm(fileName)", "_____no_output_____" ], [ "# Set the output location of the resulting .cub\ncub_loc = os.path.splitext(fileName)[0] + '.cub'\n\ntry: \n isis.hrsc2isis(from_=fileName, to=cub_loc)\nexcept ProcessError as e:\n print(e.stderr)\n\ntry:\n isis.spiceinit(from_=cub_loc, shape='ellipsoid', ckpredicted=True, spkpredicted=True)\nexcept ProcessError as e:\n print(e.stderr)\n\n# driver = MexHrscPds3NaifSpiceDriver(fileName)\n# print(driver.metakernel)\n \n# with MexHrscPds3NaifSpiceDriver(fileName) as driver:\n# usgscsmString = to_usgscsm(driver)\n# usgscsm_dict = json.loads(usgscsmString)\n \n# csm_isd = os.path.splitext(fileName)[0] + '.json'\n# json.dump(usgscsm_dict, open(csm_isd, 'w'))", "_____no_output_____" ], [ "csm_isd = os.path.splitext(fileName)[0] + '.json'\n\ncsmisis_diff_lv_plot, csmisis_diff_ephem_plot, external_orientation_data = vis.external_orientation_diff(csm_isd, cub_loc, 10, 50, 600, 600)", "_____no_output_____" ], [ "csmisis_diff_lv_plot_bytes = csmisis_diff_lv_plot.to_image(format=\"png\")\ncsmisis_diff_ephem_plot_bytes = csmisis_diff_ephem_plot.to_image(format=\"png\")\nImage(csmisis_diff_lv_plot_bytes)", "_____no_output_____" ], [ "Image(csmisis_diff_ephem_plot_bytes)", "_____no_output_____" ], [ "external_orientation_data[['diffx', 'diffy', 'diffz', 'diffu', 'diffv', 'diffw']].describe()", "_____no_output_____" ], [ "isis2csm_plot, csm2isis_plot, isiscsm_plotlatlon, isiscsm_plotbf, isis2csm_data, csm2isis_data, isiscsm_latlondata, isiscsm_bfdata = vis.reprojection_diff(csm_isd, cub_loc, 10, 50, 500, 500)", "_____no_output_____" ], [ "Image(isis2csm_plot.to_image())", "_____no_output_____" ], [ "isis2csm_data[['diff sample', 'diff line']].describe()", "_____no_output_____" ], [ "Image(csm2isis_plot.to_image())", "_____no_output_____" ], [ "csm2isis_data[['diff sample', 'diff line']].describe()", "_____no_output_____" ], [ "Image(isiscsm_plotlatlon.to_image())", "_____no_output_____" ], [ "Image(isiscsm_plotbf.to_image())", "_____no_output_____" ], [ "isiscsm_bfdata[['diffx', 'diffy', 'diffz']].describe()", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Inference code for running on kaggle server", "_____no_output_____" ] ], [ [ "!pip install ../input/pretrainedmodels/pretrainedmodels-0.7.4/pretrainedmodels-0.7.4/ > /dev/null # no output", "_____no_output_____" ], [ "import gc\nimport os\nimport random\nimport sys\nimport six\nimport math\nfrom pathlib import Path\nfrom tqdm import tqdm_notebook as tqdm\nfrom IPython.core.display import display, HTML\nfrom typing import List\n\nimport plotly.offline as py\nimport plotly.graph_objs as go\nimport plotly.express as px\nimport plotly.figure_factory as ff\nfrom plotly import tools, subplots\npy.init_notebook_mode(connected=True)\n\nimport numpy\nimport numpy as np\nimport pandas as pd \nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport albumentations as A\nimport cv2\nfrom sklearn import preprocessing\nfrom sklearn.model_selection import KFold\nfrom skimage.transform import AffineTransform, warp\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom torch.nn import init, Sequential\nfrom torch.nn.parameter import Parameter\nfrom torch.utils.data.dataset import Dataset\nfrom torch.utils.data.dataloader import DataLoader\n\nimport pretrainedmodels\n\n# --- setup ---\npd.set_option('max_columns', 50)", "_____no_output_____" ], [ "debug=False\nsubmission=True\nbatch_size=32\ndevice='cuda:0'\nout='.'\n#load_model_path='/kaggle/input/pytorch-mixup1/model_097889.pt'\nload_model_path='.'\nimage_size=128\nthreshold=40.#20\nmodel_name='se_resnext50_32x4d'", "_____no_output_____" ], [ "datadir = Path('/kaggle/input/bengaliai-cv19')\nfeatherdir = Path('/kaggle/input/bengaliaicv19feather')\noutdir = Path('.')", "_____no_output_____" ], [ "# Read in the data CSV files\n# train = pd.read_csv(datadir/'train.csv')\n# test = pd.read_csv(datadir/'test.csv')\n# sample_submission = pd.read_csv(datadir/'sample_submission.csv')\n# class_map = pd.read_csv(datadir/'class_map.csv')", "_____no_output_____" ] ], [ [ "## Dataset", "_____no_output_____" ] ], [ [ "\"\"\"\nReferenced `chainer.dataset.DatasetMixin` to work with pytorch Dataset.\n\"\"\"\n\nclass DatasetMixin(Dataset):\n\n def __init__(self, transform=None):\n self.transform = transform\n\n def __getitem__(self, index):\n \"\"\"Returns an example or a sequence of examples.\"\"\"\n if torch.is_tensor(index):\n index = index.tolist()\n if isinstance(index, slice):\n current, stop, step = index.indices(len(self))\n return [self.get_example_wrapper(i) for i in\n six.moves.range(current, stop, step)]\n elif isinstance(index, list) or isinstance(index, numpy.ndarray):\n return [self.get_example_wrapper(i) for i in index]\n else:\n return self.get_example_wrapper(index)\n\n def __len__(self):\n \"\"\"Returns the number of data points.\"\"\"\n raise NotImplementedError\n\n def get_example_wrapper(self, i):\n \"\"\"Wrapper of `get_example`, to apply `transform` if necessary\"\"\"\n example = self.get_example(i)\n if self.transform:\n example = self.transform(example)\n return example\n\n def get_example(self, i):\n \"\"\"Returns the i-th example.\n\n Implementations should override it. It should raise :class:`IndexError`\n if the index is invalid.\n\n Args:\n i (int): The index of the example.\n\n Returns:\n The i-th example.\n\n \"\"\"\n raise NotImplementedError\n", "_____no_output_____" ], [ "class BengaliAIDataset(DatasetMixin):\n def __init__(self, images, labels=None, transform=None, indices=None):\n super(BengaliAIDataset, self).__init__(transform=transform)\n self.images = images\n self.labels = labels\n if indices is None:\n indices = np.arange(len(images))\n self.indices = indices\n self.train = labels is not None\n\n def __len__(self):\n \"\"\"return length of this dataset\"\"\"\n return len(self.indices)\n\n def get_example(self, i):\n \"\"\"Return i-th data\"\"\"\n i = self.indices[i]\n x = self.images[i]\n x = (255 - x).astype(np.float32) / 255.\n if self.train:\n y = self.labels[i]\n return x, y\n else:\n return x\n", "_____no_output_____" ] ], [ [ "### Data augmentation/processing", "_____no_output_____" ] ], [ [ "\"\"\"\nFrom https://www.kaggle.com/corochann/deep-learning-cnn-with-chainer-lb-0-99700\n\"\"\"\n\ndef affine_image(img):\n \"\"\"\n\n Args:\n img: (h, w) or (1, h, w)\n\n Returns:\n img: (h, w)\n \"\"\"\n # ch, h, w = img.shape\n # img = img / 255.\n if img.ndim == 3:\n img = img[0]\n\n # --- scale ---\n min_scale = 0.8\n max_scale = 1.2\n sx = np.random.uniform(min_scale, max_scale)\n sy = np.random.uniform(min_scale, max_scale)\n\n # --- rotation ---\n max_rot_angle = 7\n rot_angle = np.random.uniform(-max_rot_angle, max_rot_angle) * np.pi / 180.\n\n # --- shear ---\n max_shear_angle = 10\n shear_angle = np.random.uniform(-max_shear_angle, max_shear_angle) * np.pi / 180.\n\n # --- translation ---\n max_translation = 4\n tx = np.random.randint(-max_translation, max_translation)\n ty = np.random.randint(-max_translation, max_translation)\n\n tform = AffineTransform(scale=(sx, sy), rotation=rot_angle, shear=shear_angle,\n translation=(tx, ty))\n transformed_image = warp(img, tform)\n assert transformed_image.ndim == 2\n return transformed_image\n\n\ndef crop_char_image(image, threshold=40./255.):\n assert image.ndim == 2\n is_black = image > threshold\n\n is_black_vertical = np.sum(is_black, axis=0) > 0\n is_black_horizontal = np.sum(is_black, axis=1) > 0\n left = np.argmax(is_black_horizontal)\n right = np.argmax(is_black_horizontal[::-1])\n top = np.argmax(is_black_vertical)\n bottom = np.argmax(is_black_vertical[::-1])\n height, width = image.shape\n cropped_image = image[left:height - right, top:width - bottom]\n return cropped_image\n\n\ndef resize(image, size=(224, 224)):\n return cv2.resize(image, size, interpolation=cv2.INTER_AREA)", "_____no_output_____" ], [ "def add_gaussian_noise(x, sigma):\n x += np.random.randn(*x.shape) * sigma\n x = np.clip(x, 0., 1.)\n return x\n\ndef _evaluate_ratio(ratio):\n if ratio <= 0.:\n return False\n return np.random.uniform() < ratio\n\n\ndef apply_aug(aug, image):\n return aug(image=image)['image']\n\nclass Transform:\n def __init__(self, affine=True, crop=False, size=(224, 224),\n normalize=True, train=True, threshold=40.,\n sigma=-1., ssr_ratio=0.):\n self.affine = affine\n self.crop = crop\n self.size = size\n self.normalize = normalize\n self.train = train\n self.threshold = threshold / 255.\n self.sigma = sigma / 255.\n self.ssr_ratio = ssr_ratio\n\n def __call__(self, example):\n if self.train:\n x, y = example\n else:\n x = example\n # --- Augmentation ---\n if self.affine:\n x = affine_image(x)\n\n # --- Train/Test common preprocessing ---\n if self.crop:\n x = crop_char_image(x, threshold=self.threshold)\n if self.size is not None:\n x = resize(x, size=self.size)\n if self.sigma > 0.:\n x = add_gaussian_noise(x, sigma=self.sigma)\n if _evaluate_ratio(self.ssr_ratio):\n x = apply_aug(A.ShiftScaleRotate(\n shift_limit=0.0625,\n scale_limit=0.1,\n rotate_limit=15,\n p=1.0), x) \n if self.normalize:\n x = (x.astype(np.float32) - 0.0692) / 0.2051\n if x.ndim == 2:\n x = x[None, :, :]\n x = x.astype(np.float32)\n if self.train:\n y = y.astype(np.int64)\n return x, y\n else:\n return x", "_____no_output_____" ], [ "def residual_add(lhs, rhs):\n lhs_ch, rhs_ch = lhs.shape[1], rhs.shape[1]\n if lhs_ch < rhs_ch:\n out = lhs + rhs[:, :lhs_ch]\n elif lhs_ch > rhs_ch:\n out = torch.cat([lhs[:, :rhs_ch] + rhs, lhs[:, rhs_ch:]], dim=1)\n else:\n out = lhs + rhs\n return out\n", "_____no_output_____" ], [ "class LazyLoadModule(nn.Module):\n \"\"\"Lazy buffer/parameter loading using load_state_dict_pre_hook\n\n Define all buffer/parameter in `_lazy_buffer_keys`/`_lazy_parameter_keys` and\n save buffer with `register_buffer`/`register_parameter`\n method, which can be outside of __init__ method.\n Then this module can load any shape of Tensor during de-serializing.\n\n Note that default value of lazy buffer is torch.Tensor([]), while lazy parameter is None.\n \"\"\"\n _lazy_buffer_keys: List[str] = [] # It needs to be override to register lazy buffer\n _lazy_parameter_keys: List[str] = [] # It needs to be override to register lazy parameter\n\n def __init__(self):\n super(LazyLoadModule, self).__init__()\n for k in self._lazy_buffer_keys:\n self.register_buffer(k, torch.tensor([]))\n for k in self._lazy_parameter_keys:\n self.register_parameter(k, None)\n self._register_load_state_dict_pre_hook(self._hook)\n\n def _hook(self, state_dict, prefix, local_metadata, strict, missing_keys,\n unexpected_keys, error_msgs):\n for key in self._lazy_buffer_keys:\n self.register_buffer(key, state_dict[prefix + key])\n\n for key in self._lazy_parameter_keys:\n self.register_parameter(key, Parameter(state_dict[prefix + key]))\n", "_____no_output_____" ], [ "class LazyLinear(LazyLoadModule):\n \"\"\"Linear module with lazy input inference\n\n `in_features` can be `None`, and it is determined at the first time of forward step dynamically.\n \"\"\"\n\n __constants__ = ['bias', 'in_features', 'out_features']\n _lazy_parameter_keys = ['weight']\n\n def __init__(self, in_features, out_features, bias=True):\n super(LazyLinear, self).__init__()\n self.in_features = in_features\n self.out_features = out_features\n if bias:\n self.bias = Parameter(torch.Tensor(out_features))\n else:\n self.register_parameter('bias', None)\n\n if in_features is not None:\n self.weight = Parameter(torch.Tensor(out_features, in_features))\n self.reset_parameters()\n\n def reset_parameters(self):\n init.kaiming_uniform_(self.weight, a=math.sqrt(5))\n if self.bias is not None:\n fan_in, _ = init._calculate_fan_in_and_fan_out(self.weight)\n bound = 1 / math.sqrt(fan_in)\n init.uniform_(self.bias, -bound, bound)\n\n def forward(self, input):\n if self.weight is None:\n self.in_features = input.shape[-1]\n self.weight = Parameter(torch.Tensor(self.out_features, self.in_features))\n self.reset_parameters()\n\n # Need to send lazy defined parameter to device...\n self.to(input.device)\n return F.linear(input, self.weight, self.bias)\n\n def extra_repr(self):\n return 'in_features={}, out_features={}, bias={}'.format(\n self.in_features, self.out_features, self.bias is not None\n )\n", "_____no_output_____" ], [ "class LinearBlock(nn.Module):\n\n def __init__(self, in_features, out_features, bias=True,\n use_bn=True, activation=F.relu, dropout_ratio=-1, residual=False,):\n super(LinearBlock, self).__init__()\n if in_features is None:\n self.linear = LazyLinear(in_features, out_features, bias=bias)\n else:\n self.linear = nn.Linear(in_features, out_features, bias=bias)\n if use_bn:\n self.bn = nn.BatchNorm1d(out_features)\n if dropout_ratio > 0.:\n self.dropout = nn.Dropout(p=dropout_ratio)\n else:\n self.dropout = None\n self.activation = activation\n self.use_bn = use_bn\n self.dropout_ratio = dropout_ratio\n self.residual = residual\n\n def __call__(self, x):\n h = self.linear(x)\n if self.use_bn:\n h = self.bn(h)\n if self.activation is not None:\n h = self.activation(h)\n if self.residual:\n h = residual_add(h, x)\n if self.dropout_ratio > 0:\n h = self.dropout(h)\n return h", "_____no_output_____" ], [ "class PretrainedCNN(nn.Module):\n def __init__(self, model_name='se_resnext50_32x4d',\n in_channels=1, out_dim=10, use_bn=True,\n pretrained='imagenet'):\n super(PretrainedCNN, self).__init__()\n self.conv0 = nn.Conv2d(\n in_channels, 3, kernel_size=3, stride=1, padding=1, bias=True)\n self.base_model = pretrainedmodels.__dict__[model_name](pretrained=pretrained)\n activation = F.leaky_relu\n self.do_pooling = True\n if self.do_pooling:\n inch = self.base_model.last_linear.in_features\n else:\n inch = None\n hdim = 512\n lin1 = LinearBlock(inch, hdim, use_bn=use_bn, activation=activation, residual=False)\n lin2 = LinearBlock(hdim, out_dim, use_bn=use_bn, activation=None, residual=False)\n self.lin_layers = Sequential(lin1, lin2)\n\n def forward(self, x):\n #h = self.conv0(x)\n h = x.repeat(1,3,1,1)\n h = self.base_model.features(h)\n\n if self.do_pooling:\n h = torch.sum(h, dim=(-1, -2))\n else:\n bs, ch, height, width = h.shape\n h = h.view(bs, ch*height*width)\n for layer in self.lin_layers:\n h = layer(h)\n return h", "_____no_output_____" ] ], [ [ "## Classifier", "_____no_output_____" ] ], [ [ "def accuracy(y, t):\n pred_label = torch.argmax(y, dim=1)\n count = pred_label.shape[0]\n correct = (pred_label == t).sum().type(torch.float32)\n acc = correct / count\n return acc\n\n\nclass BengaliClassifier(nn.Module):\n def __init__(self, predictor, n_grapheme=168, n_vowel=11, n_consonant=7):\n super(BengaliClassifier, self).__init__()\n self.n_grapheme = n_grapheme\n self.n_vowel = n_vowel\n self.n_consonant = n_consonant\n self.n_total_class = self.n_grapheme + self.n_vowel + self.n_consonant\n self.predictor = predictor\n\n self.metrics_keys = [\n 'loss', 'loss_grapheme', 'loss_vowel', 'loss_consonant',\n 'acc_grapheme', 'acc_vowel', 'acc_consonant']\n\n def forward(self, x, y=None):\n pred = self.predictor(x)\n if isinstance(pred, tuple):\n assert len(pred) == 3\n preds = pred\n else:\n assert pred.shape[1] == self.n_total_class\n preds = torch.split(pred, [self.n_grapheme, self.n_vowel, self.n_consonant], dim=1)\n loss_grapheme = F.cross_entropy(preds[0], y[:, 0])\n loss_vowel = F.cross_entropy(preds[1], y[:, 1])\n loss_consonant = F.cross_entropy(preds[2], y[:, 2])\n loss = loss_grapheme + loss_vowel + loss_consonant\n metrics = {\n 'loss': loss.item(),\n 'loss_grapheme': loss_grapheme.item(),\n 'loss_vowel': loss_vowel.item(),\n 'loss_consonant': loss_consonant.item(),\n 'acc_grapheme': accuracy(preds[0], y[:, 0]),\n 'acc_vowel': accuracy(preds[1], y[:, 1]),\n 'acc_consonant': accuracy(preds[2], y[:, 2]),\n }\n return loss, metrics, pred\n\n def calc(self, data_loader):\n device: torch.device = next(self.parameters()).device\n self.eval()\n output_list = []\n with torch.no_grad():\n for batch in tqdm(data_loader):\n batch = batch.to(device)\n pred = self.predictor(batch)\n output_list.append(pred)\n output = torch.cat(output_list, dim=0)\n preds = torch.split(output, [self.n_grapheme, self.n_vowel, self.n_consonant], dim=1)\n return preds\n\n def predict_proba(self, data_loader):\n preds = self.calc(data_loader)\n return [F.softmax(p, dim=1) for p in preds]\n\n def predict(self, data_loader):\n preds = self.calc(data_loader)\n pred_labels = [torch.argmax(p, dim=1) for p in preds]\n return pred_labels\n", "_____no_output_____" ], [ "def prepare_image(datadir, featherdir, data_type='train',\n submission=False, indices=[0, 1, 2, 3]):\n assert data_type in ['train', 'test']\n if submission:\n image_df_list = [pd.read_parquet(datadir / f'{data_type}_image_data_{i}.parquet')\n for i in indices]\n else:\n image_df_list = [pd.read_feather(featherdir / f'{data_type}_image_data_{i}.feather')\n for i in indices]\n\n print('image_df_list', len(image_df_list))\n HEIGHT = 137\n WIDTH = 236\n images = [df.iloc[:, 1:].values.reshape(-1, HEIGHT, WIDTH) for df in image_df_list]\n images = np.concatenate(images, axis=0)\n return images\n", "_____no_output_____" ], [ "# --- Model ---\ndevice = torch.device(device)\nn_grapheme = 168\nn_vowel = 11\nn_consonant = 7\nn_total = n_grapheme + n_vowel + n_consonant\nprint('n_total', n_total)\n#predictor = PretrainedCNN(in_channels=1, out_dim=n_total, model_name=model_name, pretrained=None)\n#print('predictor', type(predictor))\n\n#classifier = BengaliClassifier(predictor)", "n_total 186\n" ], [ "class WrappedModel(nn.Module):\n\tdef __init__(self, module):\n\t\tsuper(WrappedModel, self).__init__()\n\t\tself.module = module \n\tdef forward(self, x):\n\t\treturn self.module(x)", "_____no_output_____" ], [ "def build_predictor():\n predictor = PretrainedCNN(in_channels=3, out_dim=n_total, model_name=model_name, pretrained=None)\n return predictor\n\ndef build_classifier(arch, load_model_path, n_total, model_name='', device='cuda:0'):\n if isinstance(device, str):\n device = torch.device(device)\n predictor = build_predictor()\n predictor = WrappedModel(predictor)\n print('predictor', type(predictor))\n classifier = BengaliClassifier(predictor)\n if load_model_path:\n predictor.load_state_dict(torch.load(load_model_path))\n else:\n print(\"[WARNING] Unexpected value load_model_path={}\"\n .format(load_model_path))\n classifier.to(device)\n return classifier", "_____no_output_____" ], [ "def predict_core(test_images, image_size, threshold,\n arch, n_total, model_name, load_model_path, batch_size=512, device='cuda:0', **kwargs):\n classifier = build_classifier(arch, load_model_path, n_total, model_name, device=device)\n test_dataset = BengaliAIDataset(\n test_images, None,\n transform=Transform(affine=False, crop=False, size=(224, 224),\n threshold=threshold, train=False, ssr_ratio=0.0))\n print('test_dataset', len(test_dataset))\n test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n test_pred_proba = classifier.predict_proba(test_loader)\n return test_pred_proba", "_____no_output_____" ], [ "'''\nfrom torch.utils.data.dataloader import DataLoader\n\n# --- Prediction ---\ndata_type = 'test'\ntest_preds_list = []\nfor i in range(4):\n # --- prepare data ---\n indices = [i]\n test_images = prepare_image(\n datadir, featherdir, data_type=data_type, submission=submission, indices=indices)\n n_dataset = len(test_images)\n print(f'i={i}, n_dataset={n_dataset}')\n # test_data_size = 200 if debug else int(n_dataset * 0.9)\n test_dataset = BengaliAIDataset(\n test_images, None,\n transform=Transform(affine=False, crop=True, size=(image_size, image_size),\n threshold=threshold, train=False))\n print('test_dataset', len(test_dataset))\n test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n test_preds = classifier.predict(test_loader)\n test_preds_list.append(test_preds)\n del test_images\n gc.collect()\n if debug:\n break\n ''' ", "_____no_output_____" ], [ "model_dir = '/kaggle/input/pytorch-cutmix-46/'\n\nfilenames = []\nfor filename in os.listdir(model_dir):\n if filename.endswith(\".pt\"): \n print(os.path.join(model_dir, filename))\n filenames.append(filename)\n\ntrain_args_dict={\n 'load_model_path': filename,\n 'device': device,\n 'batch_size': batch_size,\n 'debug': debug,\n 'image_size': (224, 224),\n 'model_name': model_name,\n 'threshold': 40.,\n 'arch': None,}\n \n\n# --- Prediction ---\ndata_type = 'test'\ntest_preds_list = []\nfor i in range(4):\n # --- prepare data ---\n indices = [i]\n test_images = prepare_image(\n datadir, featherdir, data_type=data_type, submission=submission, indices=indices)\n n_dataset = len(test_images)\n print(f'i={i}, n_dataset={n_dataset}')\n # test_data_size = 200 if debug else int(n_dataset * 0.9)\n model_preds_list = []\n for j in range(6):\n train_args_dict.update({\n 'load_model_path': os.path.join(model_dir, filenames[j]),\n 'device': device,\n 'batch_size': batch_size,\n 'debug': debug,\n })\n print(f'j {j} updated train_args_dict {train_args_dict}')\n test_preds = predict_core(\n test_images=test_images, n_total=n_total,\n **train_args_dict)\n\n model_preds_list.append(test_preds)\n \n # --- ensemble ---\n proba0 = torch.mean(torch.stack([test_preds[0] for test_preds in model_preds_list], dim=0), dim=0)\n proba1 = torch.mean(torch.stack([test_preds[1] for test_preds in model_preds_list], dim=0), dim=0)\n proba2 = torch.mean(torch.stack([test_preds[2] for test_preds in model_preds_list], dim=0), dim=0)\n p0 = torch.argmax(proba0, dim=1).cpu().numpy()\n p1 = torch.argmax(proba1, dim=1).cpu().numpy()\n p2 = torch.argmax(proba2, dim=1).cpu().numpy()\n print('p0', p0.shape, 'p1', p1.shape, 'p2', p2.shape)\n\n test_preds_list.append([p0, p1, p2])\n if debug:\n break\n del test_images\n gc.collect()\n '''\n test_preds_list.append(test_preds)\n del test_images\n gc.collect()\n if debug:\n break\n ''' ", "/kaggle/input/pytorch-cutmix-46/model_079.pt\n/kaggle/input/pytorch-cutmix-46/model_109.pt\n/kaggle/input/pytorch-cutmix-46/model_073.pt\n/kaggle/input/pytorch-cutmix-46/model_111.pt\n/kaggle/input/pytorch-cutmix-46/model_100.pt\n/kaggle/input/pytorch-cutmix-46/model_098.pt\nimage_df_list 1\ni=0, n_dataset=3\nj 0 updated train_args_dict {'load_model_path': '/kaggle/input/pytorch-cutmix-46/model_079.pt', 'device': device(type='cuda', index=0), 'batch_size': 32, 'debug': False, 'image_size': (224, 224), 'model_name': 'se_resnext50_32x4d', 'threshold': 40.0, 'arch': None}\npredictor <class '__main__.WrappedModel'>\n" ], [ "\np0 = np.concatenate([test_preds[0] for test_preds in test_preds_list], axis=0)\np1 = np.concatenate([test_preds[1] for test_preds in test_preds_list], axis=0)\np2 = np.concatenate([test_preds[2] for test_preds in test_preds_list], axis=0)\nprint('concat:', 'p0', p0.shape, 'p1', p1.shape, 'p2', p2.shape)\n\nrow_id = []\ntarget = []\nfor i in tqdm(range(len(p0))):\n row_id += [f'Test_{i}_grapheme_root', f'Test_{i}_vowel_diacritic',\n f'Test_{i}_consonant_diacritic']\n target += [p0[i], p1[i], p2[i]]\nsubmission_df = pd.DataFrame({'row_id': row_id, 'target': target})\nsubmission_df.to_csv('submission.csv', index=False)", "100%|██████████| 12/12 [00:00<00:00, 19365.77it/s]" ], [ "'''\np0 = np.concatenate([test_preds[0].cpu().numpy() for test_preds in test_preds_list], axis=0)\np1 = np.concatenate([test_preds[1].cpu().numpy() for test_preds in test_preds_list], axis=0)\np2 = np.concatenate([test_preds[2].cpu().numpy() for test_preds in test_preds_list], axis=0)\nprint('p0', p0.shape, 'p1', p1.shape, 'p2', p2.shape)\n\nrow_id = []\ntarget = []\nfor i in tqdm(range(len(p0))):\n row_id += [f'Test_{i}_grapheme_root', f'Test_{i}_vowel_diacritic',\n f'Test_{i}_consonant_diacritic']\n target += [p0[i], p1[i], p2[i]]\nsubmission_df = pd.DataFrame({'row_id': row_id, 'target': target})\nsubmission_df.to_csv('submission.csv', index=False)\n'''", "_____no_output_____" ], [ "submission_df", "_____no_output_____" ] ], [ [ "# Check prediction", "_____no_output_____" ] ], [ [ "train = pd.read_csv(datadir/'train.csv')", "_____no_output_____" ], [ "pred_df = pd.DataFrame({\n 'grapheme_root': p0,\n 'vowel_diacritic': p1,\n 'consonant_diacritic': p2\n})", "_____no_output_____" ], [ "fig, axes = plt.subplots(2, 3, figsize=(22, 6))\nplt.title('Label Count')\nsns.countplot(x=\"grapheme_root\",data=train, ax=axes[0, 0])\nsns.countplot(x=\"vowel_diacritic\",data=train, ax=axes[0, 1])\nsns.countplot(x=\"consonant_diacritic\",data=train, ax=axes[0, 2])\nsns.countplot(x=\"grapheme_root\",data=pred_df, ax=axes[1, 0])\nsns.countplot(x=\"vowel_diacritic\",data=pred_df, ax=axes[1, 1])\nsns.countplot(x=\"consonant_diacritic\",data=pred_df, ax=axes[1, 2])\nplt.tight_layout()\nplt.show()", "_____no_output_____" ], [ "train_labels = train[['grapheme_root', 'vowel_diacritic', 'consonant_diacritic']].values", "_____no_output_____" ], [ "fig, axes = plt.subplots(1, 3, figsize=(22, 6))\nsns.distplot(train_labels[:, 0], ax=axes[0], color='green', kde=False, label='train grapheme')\nsns.distplot(train_labels[:, 1], ax=axes[1], color='green', kde=False, label='train vowel')\nsns.distplot(train_labels[:, 2], ax=axes[2], color='green', kde=False, label='train consonant')\nplt.tight_layout()", "_____no_output_____" ], [ "fig, axes = plt.subplots(1, 3, figsize=(22, 6))\nsns.distplot(p0, ax=axes[0], color='orange', kde=False, label='test grapheme')\nsns.distplot(p1, ax=axes[1], color='orange', kde=False, label='test vowel')\nsns.distplot(p2, ax=axes[2], color='orange', kde=False, label='test consonant')\nplt.legend()\nplt.tight_layout()\n", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import matplotlib.pyplot as plt\nimport numpy as np\n\ndef kmeans(points: np.ndarray, num_clusters: int, num_iterations: int) -> (np.ndarray, np.ndarray):\n \"\"\"Calculates the KMeans clusters using Euclidean distance for input points.\"\"\"\n \n num_points, point_dim = points.shape[0], points.shape[-1]\n \n # Initializes centroids as K random points from the input points, with shape [num_clusters, point_dim].\n centroids = points[np.random.choice(num_points, [num_clusters], replace=False)]\n # Augments the input points to shape [num_points, num_clusters, point_dim], for example:\n # [['x1' 'y1'] ['x2' 'y2] ['x3' 'y3']]\n # ==>\n # [[['x1' 'y1'] [['x2' 'y2'] [['x3' 'y3']\n # ['x1' 'y1'] ['x2' 'y2'] ['x3' 'y3']\n # ['x1' 'y1']] ['x2' 'y2']] ['x3' 'y3']]]\n # Such that we can take advantage of the vectorized subtraction later.\n points_augmented = np.tile(points.reshape([num_points, 1, point_dim]), [1, num_clusters, 1])\n \n for _ in range(num_iterations):\n # Calculates the element-wise diff of each point to each centroid, for example:\n # [[['x1' 'y1'] [['x2' 'y2'] [['x3' 'y3'] [[['c1x' 'c1y'] [['c1x' 'c1y'] [['c1x' 'c1y']\n # ['x1' 'y1'] ['x2' 'y2'] ['x3' 'y3'] - ['c2x' 'c2y'] ['c2x' 'c2y'] ['c2x' 'c2y']\n # ['x1' 'y1']] ['x2' 'y2']] ['x3' 'y3']]] ['c3x' 'c3y']] ['c3x' 'c3y']] ['c3x' 'c3y']]]\n diff = points_augmented - centroids\n # Calculates the Euclidean distance for each point to all centroids.\n dists = np.sqrt(np.sum(diff ** 2, axis=2))\n # Assigns the index of the closest centroid to each point.\n points_cluster = dists.argmin(axis=1)\n \n for k in range(num_clusters):\n # Updates each centroid to be the mean of all points that belong to this cluster.\n centroids[k] = points[points_cluster == k].mean(axis=0)\n \n return points_cluster, centroids\n ", "_____no_output_____" ], [ "x, k = np.random.normal(size=[200, 2]), 5\nclusters, centroids = kmeans(x, k, 10)\ncolors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']\nfor i in range(k):\n pts = x[clusters == i]\n # Plots the clustered points.\n plt.scatter(pts[:, 0], pts[:, 1], c=colors[i], marker='.')\n # Plots the centroid.\n plt.scatter(centroids[i, 0], centroids[i, 1], c=colors[i], marker='x')\nplt.show()", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code" ] ]

[ "CC-BY-4.0", "BSD-3-Clause" ]

[ "CC-BY-4.0", "BSD-3-Clause" ]

[ "CC-BY-4.0", "BSD-3-Clause" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/NeuromatchAcademy/course-content/blob/master/tutorials/W2D4_DynamicNetworks/student/W2D4_Tutorial1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ], [ "# Tutorial 1: Neural Rate Models\n**Week 2, Day 4: Dynamic Networks**\n\n**By Neuromatch Academy**\n\n__Content creators:__ Qinglong Gu, Songtin Li, Arvind Kumar, John Murray, Julijana Gjorgjieva \n\n__Content reviewers:__ Maryam Vaziri-Pashkam, Ella Batty, Lorenzo Fontolan, Richard Gao, Spiros Chavlis, Michael Waskom\n", "_____no_output_____" ], [ "**Our 2021 Sponsors, including Presenting Sponsor Facebook Reality Labs**\n\n<p align='center'><img src='https://github.com/NeuromatchAcademy/widgets/blob/master/sponsors.png?raw=True'/></p>", "_____no_output_____" ], [ "---\n# Tutorial Objectives\n\nThe brain is a complex system, not because it is composed of a large number of diverse types of neurons, but mainly because of how neurons are connected to each other. The brain is indeed a network of highly specialized neuronal networks. \n\nThe activity of a neural network constantly evolves in time. For this reason, neurons can be modeled as dynamical systems. The dynamical system approach is only one of the many modeling approaches that computational neuroscientists have developed (other points of view include information processing, statistical models, etc.). \n\nHow the dynamics of neuronal networks affect the representation and processing of information in the brain is an open question. However, signatures of altered brain dynamics present in many brain diseases (e.g., in epilepsy or Parkinson's disease) tell us that it is crucial to study network activity dynamics if we want to understand the brain.\n\nIn this tutorial, we will simulate and study one of the simplest models of biological neuronal networks. Instead of modeling and simulating individual excitatory neurons (e.g., LIF models that you implemented yesterday), we will treat them as a single homogeneous population and approximate their dynamics using a single one-dimensional equation describing the evolution of their average spiking rate in time.\n\nIn this tutorial, we will learn how to build a firing rate model of a single population of excitatory neurons. \n\n**Steps:**\n- Write the equation for the firing rate dynamics of a 1D excitatory population.\n- Visualize the response of the population as a function of parameters such as threshold level and gain, using the frequency-current (F-I) curve.\n- Numerically simulate the dynamics of the excitatory population and find the fixed points of the system. \n- Investigate the stability of the fixed points by linearizing the dynamics around them.\n \n", "_____no_output_____" ], [ "---\n# Setup", "_____no_output_____" ] ], [ [ "# Imports\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.optimize as opt # root-finding algorithm", "_____no_output_____" ], [ "# @title Figure Settings\nimport ipywidgets as widgets # interactive display\n%config InlineBackend.figure_format = 'retina'\nplt.style.use(\"https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/nma.mplstyle\")", "_____no_output_____" ], [ "# @title Helper functions\n\n\ndef plot_fI(x, f):\n plt.figure(figsize=(6, 4)) # plot the figure\n plt.plot(x, f, 'k')\n plt.xlabel('x (a.u.)', fontsize=14)\n plt.ylabel('F(x)', fontsize=14)\n plt.show()\n\n\ndef plot_dr_r(r, drdt, x_fps=None):\n plt.figure()\n plt.plot(r, drdt, 'k')\n plt.plot(r, 0. * r, 'k--')\n if x_fps is not None:\n plt.plot(x_fps, np.zeros_like(x_fps), \"ko\", ms=12)\n plt.xlabel(r'$r$')\n plt.ylabel(r'$\\frac{dr}{dt}$', fontsize=20)\n plt.ylim(-0.1, 0.1)\n\n\ndef plot_dFdt(x, dFdt):\n plt.figure()\n plt.plot(x, dFdt, 'r')\n plt.xlabel('x (a.u.)', fontsize=14)\n plt.ylabel('dF(x)', fontsize=14)\n plt.show()", "_____no_output_____" ] ], [ [ "---\n# Section 1: Neuronal network dynamics", "_____no_output_____" ] ], [ [ "# @title Video 1: Dynamic networks\nfrom ipywidgets import widgets\n\nout2 = widgets.Output()\nwith out2:\n from IPython.display import IFrame\n class BiliVideo(IFrame):\n def __init__(self, id, page=1, width=400, height=300, **kwargs):\n self.id=id\n src = 'https://player.bilibili.com/player.html?bvid={0}&page={1}'.format(id, page)\n super(BiliVideo, self).__init__(src, width, height, **kwargs)\n\n video = BiliVideo(id=\"\", width=854, height=480, fs=1)\n print('Video available at https://www.bilibili.com/video/{0}'.format(video.id))\n display(video)\n\nout1 = widgets.Output()\nwith out1:\n from IPython.display import YouTubeVideo\n video = YouTubeVideo(id=\"p848349hPyw\", width=854, height=480, fs=1, rel=0)\n print('Video available at https://youtube.com/watch?v=' + video.id)\n display(video)\n\nout = widgets.Tab([out1, out2])\nout.set_title(0, 'Youtube')\nout.set_title(1, 'Bilibili')\n\ndisplay(out)", "_____no_output_____" ] ], [ [ "## Section 1.1: Dynamics of a single excitatory population\n\nIndividual neurons respond by spiking. When we average the spikes of neurons in a population, we can define the average firing activity of the population. In this model, we are interested in how the population-averaged firing varies as a function of time and network parameters. Mathematically, we can describe the firing rate dynamic as:\n\n\\begin{align}\n\\tau \\frac{dr}{dt} &= -r + F(w\\cdot r + I_{\\text{ext}}) \\quad\\qquad (1)\n\\end{align}\n\n$r(t)$ represents the average firing rate of the excitatory population at time $t$, $\\tau$ controls the timescale of the evolution of the average firing rate, $w$ denotes the strength (synaptic weight) of the recurrent input to the population, $I_{\\text{ext}}$ represents the external input, and the transfer function $F(\\cdot)$ (which can be related to f-I curve of individual neurons described in the next sections) represents the population activation function in response to all received inputs.\n\nTo start building the model, please execute the cell below to initialize the simulation parameters.", "_____no_output_____" ] ], [ [ "# @markdown *Execute this cell to set default parameters for a single excitatory population model*\n\n\ndef default_pars_single(**kwargs):\n pars = {}\n\n # Excitatory parameters\n pars['tau'] = 1. # Timescale of the E population [ms]\n pars['a'] = 1.2 # Gain of the E population\n pars['theta'] = 2.8 # Threshold of the E population\n\n # Connection strength\n pars['w'] = 0. # E to E, we first set it to 0\n\n # External input\n pars['I_ext'] = 0.\n\n # simulation parameters\n pars['T'] = 20. # Total duration of simulation [ms]\n pars['dt'] = .1 # Simulation time step [ms]\n pars['r_init'] = 0.2 # Initial value of E\n\n # External parameters if any\n pars.update(kwargs)\n\n # Vector of discretized time points [ms]\n pars['range_t'] = np.arange(0, pars['T'], pars['dt'])\n\n return pars", "_____no_output_____" ] ], [ [ "You can now use:\n- `pars = default_pars_single()` to get all the parameters, and then you can execute `print(pars)` to check these parameters. \n- `pars = default_pars_single(T=T_sim, dt=time_step)` to set new simulation time and time step\n- To update an existing parameter dictionary, use `pars['New_para'] = value`\n\nBecause `pars` is a dictionary, it can be passed to a function that requires individual parameters as arguments using `my_func(**pars)` syntax.", "_____no_output_____" ], [ "## Section 1.2: F-I curves\nIn electrophysiology, a neuron is often characterized by its spike rate output in response to input currents. This is often called the **F-I** curve, denoting the output spike frequency (**F**) in response to different injected currents (**I**). We estimated this for an LIF neuron in yesterday's tutorial.\n\nThe transfer function $F(\\cdot)$ in Equation $1$ represents the gain of the population as a function of the total input. The gain is often modeled as a sigmoidal function, i.e., more input drive leads to a nonlinear increase in the population firing rate. The output firing rate will eventually saturate for high input values. \n\nA sigmoidal $F(\\cdot)$ is parameterized by its gain $a$ and threshold $\\theta$.\n\n$$ F(x;a,\\theta) = \\frac{1}{1+\\text{e}^{-a(x-\\theta)}} - \\frac{1}{1+\\text{e}^{a\\theta}} \\quad(2)$$\n\nThe argument $x$ represents the input to the population. Note that the second term is chosen so that $F(0;a,\\theta)=0$.\n\nMany other transfer functions (generally monotonic) can be also used. Examples are the rectified linear function $ReLU(x)$ or the hyperbolic tangent $tanh(x)$.", "_____no_output_____" ], [ "### Exercise 1: Implement F-I curve \n\nLet's first investigate the activation functions before simulating the dynamics of the entire population. \n\nIn this exercise, you will implement a sigmoidal **F-I** curve or transfer function $F(x)$, with gain $a$ and threshold level $\\theta$ as parameters.", "_____no_output_____" ] ], [ [ "def F(x, a, theta):\n \"\"\"\n Population activation function.\n\n Args:\n x (float): the population input\n a (float): the gain of the function\n theta (float): the threshold of the function\n\n Returns:\n float: the population activation response F(x) for input x\n \"\"\"\n #################################################\n ## TODO for students: compute f = F(x) ##\n # Fill out function and remove\n raise NotImplementedError(\"Student excercise: implement the f-I function\")\n #################################################\n\n # Define the sigmoidal transfer function f = F(x)\n f = ...\n\n return f\n\n\npars = default_pars_single() # get default parameters\nx = np.arange(0, 10, .1) # set the range of input\n\n# Uncomment below to test your function\n# f = F(x, pars['a'], pars['theta'])\n# plot_fI(x, f)", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_45ddc05f.py)\n\n*Example output:*\n\n<img alt='Solution hint' align='left' width=416 height=272 src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/tutorials/W2D4_DynamicNetworks/static/W2D4_Tutorial1_Solution_45ddc05f_0.png>\n\n", "_____no_output_____" ], [ "### Interactive Demo: Parameter exploration of F-I curve\nHere's an interactive demo that shows how the F-I curve changes for different values of the gain and threshold parameters. How do the gain and threshold parameters affect the F-I curve?", "_____no_output_____" ] ], [ [ "# @title\n\n# @markdown Make sure you execute this cell to enable the widget!\n\n\ndef interactive_plot_FI(a, theta):\n \"\"\"\n Population activation function.\n\n Expecxts:\n a : the gain of the function\n theta : the threshold of the function\n\n Returns:\n plot the F-I curve with give parameters\n \"\"\"\n\n # set the range of input\n x = np.arange(0, 10, .1)\n plt.figure()\n plt.plot(x, F(x, a, theta), 'k')\n plt.xlabel('x (a.u.)', fontsize=14)\n plt.ylabel('F(x)', fontsize=14)\n plt.show()\n\n\n_ = widgets.interact(interactive_plot_FI, a=(0.3, 3, 0.3), theta=(2, 4, 0.2))", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_1c0165d7.py)\n\n", "_____no_output_____" ], [ "## Section 1.3: Simulation scheme of E dynamics\n\nBecause $F(\\cdot)$ is a nonlinear function, the exact solution of Equation $1$ can not be determined via analytical methods. Therefore, numerical methods must be used to find the solution. In practice, the derivative on the left-hand side of Equation $1$ can be approximated using the Euler method on a time-grid of stepsize $\\Delta t$:\n\n\\begin{align}\n&\\frac{dr}{dt} \\approx \\frac{r[k+1]-r[k]}{\\Delta t} \n\\end{align}\nwhere $r[k] = r(k\\Delta t)$. \n\nThus,\n\n$$\\Delta r[k] = \\frac{\\Delta t}{\\tau}[-r[k] + F(w\\cdot r[k] + I_{\\text{ext}}[k];a,\\theta)]$$\n\n\nHence, Equation (1) is updated at each time step by:\n\n$$r[k+1] = r[k] + \\Delta r[k]$$\n", "_____no_output_____" ] ], [ [ "# @markdown *Execute this cell to enable the single population rate model simulator: `simulate_single`*\n\n\ndef simulate_single(pars):\n \"\"\"\n Simulate an excitatory population of neurons\n\n Args:\n pars : Parameter dictionary\n\n Returns:\n rE : Activity of excitatory population (array)\n\n Example:\n pars = default_pars_single()\n r = simulate_single(pars)\n \"\"\"\n\n # Set parameters\n tau, a, theta = pars['tau'], pars['a'], pars['theta']\n w = pars['w']\n I_ext = pars['I_ext']\n r_init = pars['r_init']\n dt, range_t = pars['dt'], pars['range_t']\n Lt = range_t.size\n\n # Initialize activity\n r = np.zeros(Lt)\n r[0] = r_init\n I_ext = I_ext * np.ones(Lt)\n\n # Update the E activity\n for k in range(Lt - 1):\n dr = dt / tau * (-r[k] + F(w * r[k] + I_ext[k], a, theta))\n r[k+1] = r[k] + dr\n\n return r\n\nhelp(simulate_single)", "_____no_output_____" ] ], [ [ "### Interactive Demo: Parameter Exploration of single population dynamics\n\nNote that $w=0$, as in the default setting, means no recurrent input to the neuron population in Equation (1). Hence, the dynamics are entirely determined by the external input $I_{\\text{ext}}$. Explore these dynamics in this interactive demo.\n\nHow does $r_{\\text{sim}}(t)$ change with different $I_{\\text{ext}}$ values? How does it change with different $\\tau$ values? Investigate the relationship between $F(I_{\\text{ext}}; a, \\theta)$ and the steady value of $r(t)$. \n\nNote that, $r_{\\rm ana}(t)$ denotes the analytical solution - you will learn how this is computed in the next section.", "_____no_output_____" ] ], [ [ "# @title\n\n# @markdown Make sure you execute this cell to enable the widget!\n\n# get default parameters\npars = default_pars_single(T=20.)\n\n\ndef Myplot_E_diffI_difftau(I_ext, tau):\n # set external input and time constant\n pars['I_ext'] = I_ext\n pars['tau'] = tau\n\n # simulation\n r = simulate_single(pars)\n\n # Analytical Solution\n r_ana = (pars['r_init']\n + (F(I_ext, pars['a'], pars['theta'])\n - pars['r_init']) * (1. - np.exp(-pars['range_t'] / pars['tau'])))\n\n # plot\n plt.figure()\n plt.plot(pars['range_t'], r, 'b', label=r'$r_{\\mathrm{sim}}$(t)', alpha=0.5,\n zorder=1)\n plt.plot(pars['range_t'], r_ana, 'b--', lw=5, dashes=(2, 2),\n label=r'$r_{\\mathrm{ana}}$(t)', zorder=2)\n plt.plot(pars['range_t'],\n F(I_ext, pars['a'], pars['theta']) * np.ones(pars['range_t'].size),\n 'k--', label=r'$F(I_{\\mathrm{ext}})$')\n plt.xlabel('t (ms)', fontsize=16.)\n plt.ylabel('Activity r(t)', fontsize=16.)\n plt.legend(loc='best', fontsize=14.)\n plt.show()\n\n\n_ = widgets.interact(Myplot_E_diffI_difftau, I_ext=(0.0, 10., 1.),\n tau=(1., 5., 0.2))", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_65dee3e7.py)\n\n", "_____no_output_____" ], [ "## Think!\nAbove, we have numerically solved a system driven by a positive input. Yet, $r_E(t)$ either decays to zero or reaches a fixed non-zero value.\n- Why doesn't the solution of the system \"explode\" in a finite time? In other words, what guarantees that $r_E$(t) stays finite? \n- Which parameter would you change in order to increase the maximum value of the response? ", "_____no_output_____" ], [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_5a95a98e.py)\n\n", "_____no_output_____" ], [ "---\n# Section 2: Fixed points of the single population system\n", "_____no_output_____" ] ], [ [ "# @title Video 2: Fixed point\nfrom ipywidgets import widgets\n\nout2 = widgets.Output()\nwith out2:\n from IPython.display import IFrame\n class BiliVideo(IFrame):\n def __init__(self, id, page=1, width=400, height=300, **kwargs):\n self.id=id\n src = 'https://player.bilibili.com/player.html?bvid={0}&page={1}'.format(id, page)\n super(BiliVideo, self).__init__(src, width, height, **kwargs)\n\n video = BiliVideo(id=\"\", width=854, height=480, fs=1)\n print('Video available at https://www.bilibili.com/video/{0}'.format(video.id))\n display(video)\n\nout1 = widgets.Output()\nwith out1:\n from IPython.display import YouTubeVideo\n video = YouTubeVideo(id=\"Ox3ELd1UFyo\", width=854, height=480, fs=1, rel=0)\n print('Video available at https://youtube.com/watch?v=' + video.id)\n display(video)\n\nout = widgets.Tab([out1, out2])\nout.set_title(0, 'Youtube')\nout.set_title(1, 'Bilibili')\n\ndisplay(out)", "_____no_output_____" ] ], [ [ "As you varied the two parameters in the last Interactive Demo, you noticed that, while at first the system output quickly changes, with time, it reaches its maximum/minimum value and does not change anymore. The value eventually reached by the system is called the **steady state** of the system, or the **fixed point**. Essentially, in the steady states the derivative with respect to time of the activity ($r$) is zero, i.e. $\\displaystyle \\frac{dr}{dt}=0$. \n\nWe can find that the steady state of the Equation. (1) by setting $\\displaystyle{\\frac{dr}{dt}=0}$ and solve for $r$:\n\n$$-r_{\\text{steady}} + F(w\\cdot r_{\\text{steady}} + I_{\\text{ext}};a,\\theta) = 0, \\qquad (3)$$\n\nWhen it exists, the solution of Equation. (3) defines a **fixed point** of the dynamical system in Equation (1). Note that if $F(x)$ is nonlinear, it is not always possible to find an analytical solution, but the solution can be found via numerical simulations, as we will do later.\n\nFrom the Interactive Demo, one could also notice that the value of $\\tau$ influences how quickly the activity will converge to the steady state from its initial value. \n\nIn the specific case of $w=0$, we can also analytically compute the solution of Equation (1) (i.e., the thick blue dashed line) and deduce the role of $\\tau$ in determining the convergence to the fixed point: \n\n$$\\displaystyle{r(t) = \\big{[}F(I_{\\text{ext}};a,\\theta) -r(t=0)\\big{]} (1-\\text{e}^{-\\frac{t}{\\tau}})} + r(t=0)$$ \\\\\n\nWe can now numerically calculate the fixed point with a root finding algorithm.", "_____no_output_____" ], [ "## Exercise 2: Visualization of the fixed points\n\nWhen it is not possible to find the solution for Equation (3) analytically, a graphical approach can be taken. To that end, it is useful to plot $\\displaystyle{\\frac{dr}{dt}}$ as a function of $r$. The values of $r$ for which the plotted function crosses zero on the y axis correspond to fixed points. \n\nHere, let us, for example, set $w=5.0$ and $I^{\\text{ext}}=0.5$. From Equation (1), you can obtain\n\n$$\\frac{dr}{dt} = [-r + F(w\\cdot r + I^{\\text{ext}})]\\,/\\,\\tau $$\n\nThen, plot the $dr/dt$ as a function of $r$, and check for the presence of fixed points. ", "_____no_output_____" ] ], [ [ "def compute_drdt(r, I_ext, w, a, theta, tau, **other_pars):\n \"\"\"Given parameters, compute dr/dt as a function of r.\n\n Args:\n r (1D array) : Average firing rate of the excitatory population\n I_ext, w, a, theta, tau (numbers): Simulation parameters to use\n other_pars : Other simulation parameters are unused by this function\n\n Returns\n drdt function for each value of r\n \"\"\"\n #########################################################################\n # TODO compute drdt and disable the error\n raise NotImplementedError(\"Finish the compute_drdt function\")\n #########################################################################\n\n # Calculate drdt\n drdt = ...\n\n return drdt\n\n\n# Define a vector of r values and the simulation parameters\nr = np.linspace(0, 1, 1000)\npars = default_pars_single(I_ext=0.5, w=5)\n\n# Uncomment to test your function\n# drdt = compute_drdt(r, **pars)\n# plot_dr_r(r, drdt)", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_c5280901.py)\n\n*Example output:*\n\n<img alt='Solution hint' align='left' width=558 height=413 src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/tutorials/W2D4_DynamicNetworks/static/W2D4_Tutorial1_Solution_c5280901_0.png>\n\n", "_____no_output_____" ], [ "## Exercise 3: Fixed point calculation\n\nWe will now find the fixed points numerically. To do so, we need to specif initial values ($r_{\\text{guess}}$) for the root-finding algorithm to start from. From the line $\\displaystyle{\\frac{dr}{dt}}$ plotted above in Exercise 2, initial values can be chosen as a set of values close to where the line crosses zero on the y axis (real fixed point).\n\nThe next cell defines three helper functions that we will use:\n\n- `my_fp_single(r_guess, **pars)` uses a root-finding algorithm to locate a fixed point near a given initial value\n- `check_fp_single(x_fp, **pars)`, verifies that the values of $r_{\\rm fp}$ for which $\\displaystyle{\\frac{dr}{dt}} = 0$ are the true fixed points\n- `my_fp_finder(r_guess_vector, **pars)` accepts an array of initial values and finds the same number of fixed points, using the above two functions", "_____no_output_____" ] ], [ [ "# @markdown *Execute this cell to enable the fixed point functions*\n\ndef my_fp_single(r_guess, a, theta, w, I_ext, **other_pars):\n \"\"\"\n Calculate the fixed point through drE/dt=0\n\n Args:\n r_guess : Initial value used for scipy.optimize function\n a, theta, w, I_ext : simulation parameters\n\n Returns:\n x_fp : value of fixed point\n \"\"\"\n # define the right hand of E dynamics\n def my_WCr(x):\n r = x\n drdt = (-r + F(w * r + I_ext, a, theta))\n y = np.array(drdt)\n\n return y\n\n x0 = np.array(r_guess)\n x_fp = opt.root(my_WCr, x0).x.item()\n\n return x_fp\n\n\ndef check_fp_single(x_fp, a, theta, w, I_ext, mytol=1e-4, **other_pars):\n \"\"\"\n Verify |dr/dt| < mytol\n\n Args:\n fp : value of fixed point\n a, theta, w, I_ext: simulation parameters\n mytol : tolerance, default as 10^{-4}\n\n Returns :\n Whether it is a correct fixed point: True/False\n \"\"\"\n # calculate Equation(3)\n y = x_fp - F(w * x_fp + I_ext, a, theta)\n\n # Here we set tolerance as 10^{-4}\n return np.abs(y) < mytol\n\n\ndef my_fp_finder(pars, r_guess_vector, mytol=1e-4):\n \"\"\"\n Calculate the fixed point(s) through drE/dt=0\n\n Args:\n pars : Parameter dictionary\n r_guess_vector : Initial values used for scipy.optimize function\n mytol : tolerance for checking fixed point, default as 10^{-4}\n\n Returns:\n x_fps : values of fixed points\n\n \"\"\"\n x_fps = []\n correct_fps = []\n for r_guess in r_guess_vector:\n x_fp = my_fp_single(r_guess, **pars)\n if check_fp_single(x_fp, **pars, mytol=mytol):\n x_fps.append(x_fp)\n\n return x_fps\n\nhelp(my_fp_finder)", "_____no_output_____" ], [ "r = np.linspace(0, 1, 1000)\npars = default_pars_single(I_ext=0.5, w=5)\ndrdt = compute_drdt(r, **pars)\n\n#############################################################################\n# TODO for students:\n# Define initial values close to the intersections of drdt and y=0\n# (How many initial values? Hint: How many times do the two lines intersect?)\n# Calculate the fixed point with these initial values and plot them\n#############################################################################\nr_guess_vector = [...]\n\n# Uncomment to test your values\n# x_fps = my_fp_finder(pars, r_guess_vector)\n# plot_dr_r(r, drdt, x_fps)", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_0637b6bf.py)\n\n*Example output:*\n\n<img alt='Solution hint' align='left' width=558 height=413 src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/tutorials/W2D4_DynamicNetworks/static/W2D4_Tutorial1_Solution_0637b6bf_0.png>\n\n", "_____no_output_____" ], [ "## Interactive Demo: fixed points as a function of recurrent and external inputs.\n\nYou can now explore how the previous plot changes when the recurrent coupling $w$ and the external input $I_{\\text{ext}}$ take different values. How does the number of fixed points change?", "_____no_output_____" ] ], [ [ "# @title\n\n# @markdown Make sure you execute this cell to enable the widget!\n\n\ndef plot_intersection_single(w, I_ext):\n # set your parameters\n pars = default_pars_single(w=w, I_ext=I_ext)\n\n # find fixed points\n r_init_vector = [0, .4, .9]\n x_fps = my_fp_finder(pars, r_init_vector)\n\n # plot\n r = np.linspace(0, 1., 1000)\n drdt = (-r + F(w * r + I_ext, pars['a'], pars['theta'])) / pars['tau']\n\n plot_dr_r(r, drdt, x_fps)\n\n_ = widgets.interact(plot_intersection_single, w=(1, 7, 0.2),\n I_ext=(0, 3, 0.1))", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_20486792.py)\n\n", "_____no_output_____" ], [ "---\n# Summary\n\nIn this tutorial, we have investigated the dynamics of a rate-based single population of neurons.\n\nWe learned about:\n- The effect of the input parameters and the time constant of the network on the dynamics of the population.\n- How to find the fixed point(s) of the system.\n\nNext, we have two Bonus, but important concepts in dynamical system analysis and simulation. If you have time left, watch the next video and proceed to solve the exercises. You will learn:\n\n- How to determine the stability of a fixed point by linearizing the system.\n- How to add realistic inputs to our model.", "_____no_output_____" ], [ "---\n# Bonus 1: Stability of a fixed point", "_____no_output_____" ] ], [ [ "# @title Video 3: Stability of fixed points\nfrom ipywidgets import widgets\n\nout2 = widgets.Output()\nwith out2:\n from IPython.display import IFrame\n class BiliVideo(IFrame):\n def __init__(self, id, page=1, width=400, height=300, **kwargs):\n self.id=id\n src = 'https://player.bilibili.com/player.html?bvid={0}&page={1}'.format(id, page)\n super(BiliVideo, self).__init__(src, width, height, **kwargs)\n\n video = BiliVideo(id=\"\", width=854, height=480, fs=1)\n print('Video available at https://www.bilibili.com/video/{0}'.format(video.id))\n display(video)\n\nout1 = widgets.Output()\nwith out1:\n from IPython.display import YouTubeVideo\n video = YouTubeVideo(id=\"KKMlWWU83Jg\", width=854, height=480, fs=1, rel=0)\n print('Video available at https://youtube.com/watch?v=' + video.id)\n display(video)\n\nout = widgets.Tab([out1, out2])\nout.set_title(0, 'Youtube')\nout.set_title(1, 'Bilibili')\n\ndisplay(out)", "_____no_output_____" ] ], [ [ "#### Initial values and trajectories\n\nHere, let us first set $w=5.0$ and $I_{\\text{ext}}=0.5$, and investigate the dynamics of $r(t)$ starting with different initial values $r(0) \\equiv r_{\\text{init}}$. We will plot the trajectories of $r(t)$ with $r_{\\text{init}} = 0.0, 0.1, 0.2,..., 0.9$.", "_____no_output_____" ] ], [ [ "# @markdown Execute this cell to see the trajectories!\n\npars = default_pars_single()\npars['w'] = 5.0\npars['I_ext'] = 0.5\n\nplt.figure(figsize=(8, 5))\nfor ie in range(10):\n pars['r_init'] = 0.1 * ie # set the initial value\n r = simulate_single(pars) # run the simulation\n\n # plot the activity with given initial\n plt.plot(pars['range_t'], r, 'b', alpha=0.1 + 0.1 * ie,\n label=r'r$_{\\mathrm{init}}$=%.1f' % (0.1 * ie))\n\nplt.xlabel('t (ms)')\nplt.title('Two steady states?')\nplt.ylabel(r'$r$(t)')\nplt.legend(loc=[1.01, -0.06], fontsize=14)\nplt.show()", "_____no_output_____" ] ], [ [ "## Interactive Demo: dynamics as a function of the initial value\n\nLet's now set $r_{\\rm init}$ to a value of your choice in this demo. How does the solution change? What do you observe?", "_____no_output_____" ] ], [ [ "# @title\n\n# @markdown Make sure you execute this cell to enable the widget!\n\npars = default_pars_single(w=5.0, I_ext=0.5)\n\ndef plot_single_diffEinit(r_init):\n pars['r_init'] = r_init\n r = simulate_single(pars)\n\n plt.figure()\n plt.plot(pars['range_t'], r, 'b', zorder=1)\n plt.plot(0, r[0], 'bo', alpha=0.7, zorder=2)\n plt.xlabel('t (ms)', fontsize=16)\n plt.ylabel(r'$r(t)$', fontsize=16)\n plt.ylim(0, 1.0)\n plt.show()\n\n\n_ = widgets.interact(plot_single_diffEinit, r_init=(0, 1, 0.02))", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_4d2de6a0.py)\n\n", "_____no_output_____" ], [ "### Stability analysis via linearization of the dynamics\n\nJust like Equation $1$ in the case ($w=0$) discussed above, a generic linear system \n$$\\frac{dx}{dt} = \\lambda (x - b),$$ \nhas a fixed point for $x=b$. The analytical solution of such a system can be found to be:\n$$x(t) = b + \\big{(} x(0) - b \\big{)} \\text{e}^{\\lambda t}.$$ \nNow consider a small perturbation of the activity around the fixed point: $x(0) = b+ \\epsilon$, where $|\\epsilon| \\ll 1$. Will the perturbation $\\epsilon(t)$ grow with time or will it decay to the fixed point? The evolution of the perturbation with time can be written, using the analytical solution for $x(t)$, as:\n $$\\epsilon (t) = x(t) - b = \\epsilon \\text{e}^{\\lambda t}$$\n\n- if $\\lambda < 0$, $\\epsilon(t)$ decays to zero, $x(t)$ will still converge to $b$ and the fixed point is \"**stable**\".\n\n- if $\\lambda > 0$, $\\epsilon(t)$ grows with time, $x(t)$ will leave the fixed point $b$ exponentially, and the fixed point is, therefore, \"**unstable**\" .", "_____no_output_____" ], [ "### Compute the stability of Equation $1$\n\nSimilar to what we did in the linear system above, in order to determine the stability of a fixed point $r^{*}$ of the excitatory population dynamics, we perturb Equation (1) around $r^{*}$ by $\\epsilon$, i.e. $r = r^{*} + \\epsilon$. We can plug in Equation (1) and obtain the equation determining the time evolution of the perturbation $\\epsilon(t)$:\n\n\\begin{align}\n\\tau \\frac{d\\epsilon}{dt} \\approx -\\epsilon + w F'(w\\cdot r^{*} + I_{\\text{ext}};a,\\theta) \\epsilon \n\\end{align}\n\nwhere $F'(\\cdot)$ is the derivative of the transfer function $F(\\cdot)$. We can rewrite the above equation as:\n\n\\begin{align}\n\\frac{d\\epsilon}{dt} \\approx \\frac{\\epsilon}{\\tau }[-1 + w F'(w\\cdot r^* + I_{\\text{ext}};a,\\theta)] \n\\end{align}\n\nThat is, as in the linear system above, the value of\n\n$$\\lambda = [-1+ wF'(w\\cdot r^* + I_{\\text{ext}};a,\\theta)]/\\tau \\qquad (4)$$\n\ndetermines whether the perturbation will grow or decay to zero, i.e., $\\lambda$ defines the stability of the fixed point. This value is called the **eigenvalue** of the dynamical system.", "_____no_output_____" ], [ "## Exercise 4: Compute $dF$\n\nThe derivative of the sigmoid transfer function is:\n\\begin{align} \n\\frac{dF}{dx} & = \\frac{d}{dx} (1+\\exp\\{-a(x-\\theta)\\})^{-1} \\\\\n& = a\\exp\\{-a(x-\\theta)\\} (1+\\exp\\{-a(x-\\theta)\\})^{-2}. \\qquad (5)\n\\end{align}\n\nLet's now find the expression for the derivative $\\displaystyle{\\frac{dF}{dx}}$ in the following cell and plot it.", "_____no_output_____" ] ], [ [ "def dF(x, a, theta):\n \"\"\"\n Population activation function.\n\n Args:\n x : the population input\n a : the gain of the function\n theta : the threshold of the function\n\n Returns:\n dFdx : the population activation response F(x) for input x\n \"\"\"\n\n ###########################################################################\n # TODO for students: compute dFdx ##\n raise NotImplementedError(\"Student excercise: compute the deravitive of F\")\n ###########################################################################\n\n # Calculate the population activation\n dFdx = ...\n\n return dFdx\n\n\npars = default_pars_single() # get default parameters\nx = np.arange(0, 10, .1) # set the range of input\n\n# Uncomment below to test your function\n# df = dF(x, pars['a'], pars['theta'])\n# plot_dFdt(x, df)", "_____no_output_____" ] ], [ [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_ce2e3bc5.py)\n\n*Example output:*\n\n<img alt='Solution hint' align='left' width=560 height=416 src=https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/tutorials/W2D4_DynamicNetworks/static/W2D4_Tutorial1_Solution_ce2e3bc5_0.png>\n\n", "_____no_output_____" ], [ "## Exercise 5: Compute eigenvalues\n\nAs discussed above, for the case with $w=5.0$ and $I_{\\text{ext}}=0.5$, the system displays **three** fixed points. However, when we simulated the dynamics and varied the initial conditions $r_{\\rm init}$, we could only obtain **two** steady states. In this exercise, we will now check the stability of each of the three fixed points by calculating the corresponding eigenvalues with the function `eig_single`. Check the sign of each eigenvalue (i.e., stability of each fixed point). How many of the fixed points are stable?\n\nNote that the expression of the eigenvalue at fixed point $r^*$\n$$\\lambda = [-1+ wF'(w\\cdot r^* + I_{\\text{ext}};a,\\theta)]/\\tau$$", "_____no_output_____" ] ], [ [ "def eig_single(fp, tau, a, theta, w, I_ext, **other_pars):\n \"\"\"\n Args:\n fp : fixed point r_fp\n tau, a, theta, w, I_ext : Simulation parameters\n\n Returns:\n eig : eigevalue of the linearized system\n \"\"\"\n #####################################################################\n ## TODO for students: compute eigenvalue and disable the error\n raise NotImplementedError(\"Student excercise: compute the eigenvalue\")\n ######################################################################\n # Compute the eigenvalue\n eig = ...\n\n return eig\n\n\n# Find the eigenvalues for all fixed points of Exercise 2\npars = default_pars_single(w=5, I_ext=.5)\nr_guess_vector = [0, .4, .9]\nx_fp = my_fp_finder(pars, r_guess_vector)\n\n# Uncomment below lines after completing the eig_single function.\n\n# for fp in x_fp:\n# eig_fp = eig_single(fp, **pars)\n# print(f'Fixed point1 at {fp:.3f} with Eigenvalue={eig_fp:.3f}')", "_____no_output_____" ] ], [ [ "**SAMPLE OUTPUT**\n\n```\nFixed point1 at 0.042 with Eigenvalue=-0.583\nFixed point2 at 0.447 with Eigenvalue=0.498\nFixed point3 at 0.900 with Eigenvalue=-0.626\n```", "_____no_output_____" ], [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_e285f60d.py)\n\n", "_____no_output_____" ], [ "## Think! \nThroughout the tutorial, we have assumed $w> 0 $, i.e., we considered a single population of **excitatory** neurons. What do you think will be the behavior of a population of inhibitory neurons, i.e., where $w> 0$ is replaced by $w< 0$? ", "_____no_output_____" ], [ "[*Click for solution*](https://github.com/NeuromatchAcademy/course-content/tree/master//tutorials/W2D4_DynamicNetworks/solutions/W2D4_Tutorial1_Solution_579bc9c9.py)\n\n", "_____no_output_____" ], [ "---\n# Bonus 2: Noisy input drives the transition between two stable states\n\n", "_____no_output_____" ], [ "## Ornstein-Uhlenbeck (OU) process\n\nAs discussed in several previous tutorials, the OU process is usually used to generate a noisy input into the neuron. The OU input $\\eta(t)$ follows: \n\n$$\\tau_\\eta \\frac{d}{dt}\\eta(t) = -\\eta (t) + \\sigma_\\eta\\sqrt{2\\tau_\\eta}\\xi(t)$$\n\nExecute the following function `my_OU(pars, sig, myseed=False)` to generate an OU process.", "_____no_output_____" ] ], [ [ "# @title OU process `my_OU(pars, sig, myseed=False)`\n\n# @markdown Make sure you execute this cell to visualize the noise!\n\n\ndef my_OU(pars, sig, myseed=False):\n \"\"\"\n A functions that generates Ornstein-Uhlenback process\n\n Args:\n pars : parameter dictionary\n sig : noise amplitute\n myseed : random seed. int or boolean\n\n Returns:\n I : Ornstein-Uhlenbeck input current\n \"\"\"\n\n # Retrieve simulation parameters\n dt, range_t = pars['dt'], pars['range_t']\n Lt = range_t.size\n tau_ou = pars['tau_ou'] # [ms]\n\n # set random seed\n if myseed:\n np.random.seed(seed=myseed)\n else:\n np.random.seed()\n\n # Initialize\n noise = np.random.randn(Lt)\n I_ou = np.zeros(Lt)\n I_ou[0] = noise[0] * sig\n\n # generate OU\n for it in range(Lt - 1):\n I_ou[it + 1] = (I_ou[it]\n + dt / tau_ou * (0. - I_ou[it])\n + np.sqrt(2 * dt / tau_ou) * sig * noise[it + 1])\n\n return I_ou\n\n\npars = default_pars_single(T=100)\npars['tau_ou'] = 1. # [ms]\nsig_ou = 0.1\nI_ou = my_OU(pars, sig=sig_ou, myseed=2020)\nplt.figure(figsize=(10, 4))\nplt.plot(pars['range_t'], I_ou, 'r')\nplt.xlabel('t (ms)')\nplt.ylabel(r'$I_{\\mathrm{OU}}$')\nplt.show()", "_____no_output_____" ] ], [ [ "## Example: Up-Down transition\n\nIn the presence of two or more fixed points, noisy inputs can drive a transition between the fixed points! Here, we stimulate an E population for 1,000 ms applying OU inputs.", "_____no_output_____" ] ], [ [ "# @title Simulation of an E population with OU inputs\n\n# @markdown Make sure you execute this cell to spot the Up-Down states!\n\npars = default_pars_single(T=1000)\npars['w'] = 5.0\nsig_ou = 0.7\npars['tau_ou'] = 1. # [ms]\npars['I_ext'] = 0.56 + my_OU(pars, sig=sig_ou, myseed=2020)\n\nr = simulate_single(pars)\n\nplt.figure(figsize=(10, 4))\nplt.plot(pars['range_t'], r, 'b', alpha=0.8)\nplt.xlabel('t (ms)')\nplt.ylabel(r'$r(t)$')\nplt.show()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# 人工智能＼机器学习和深度学习的概念及关系\n\n人工智能、机器学习和深度学习的概念在近些年十分火热，但很多从业者也难以说清它们之间的关系，外行人更是雾里看花。学习深度学习，需要先从三个概念的正本清源开始。\n\n三者覆盖的技术范畴是逐层递减的，人工智能是最宽泛的概念，机器学习则是实现人工智能的一种方式，也是目前较有效的方式。深度学习是机器学习算法中最热的一个分支，在近些年取得了显著的进展，并代替了多数传统机器学习算法。所以，三者的关系可用下图表示，人工智能 > 机器学习 > 深度学习。\n\n\n\n<center>\n \n\n \n</center>\n<center>图1：人工智能、机器学习和深度学习三者之间的概念范围</center>\n<br/>\n\n如字面含义，人工智能是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的科学。由于这个定义只阐述了目标，而没限定方法。所以，实现人工智能存在的诸多方法和分支，导致其变成一个“大杂烩”式的学科。\n\n与此不同，机器学习，尤其是监督学习则有更加明确的指代。机器学习是专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。这句话有点“云山雾罩”的感觉，让人不知所云。\n\n机器学习的实现步骤可以分成两步，训练和预测。这两个专业名词类似于归纳和演绎的含义。归纳是从具体案例中抽象一般规律，机器学习中的“训练”亦是如此。从一定数量的样本（已知模型输入$X$和模型输出$Y$）中，学习出输出$Ｙ$与输入$Ｘ$的关系（可以想象成是某种表达式）。演绎则是从一般规律推导出具体案例的结果，机器学习中的预测亦是如此。基于训练得到的$Ｙ$与$Ｘ$之间的关系，遇到新出现的输入$Ｘ$，计算出输出$Ｙ$。在多数时候，通过模型计算得到的输出，如果和真实场景中的输出一致，说明模型是有效的。\n\n下面以“机器从牛顿第二定律实验中学习知识”为案例，让读者深入理解下机器学习（监督学习）到底是怎样的一种技术方法。机器学习的方法论和人类科研的过程有异曲同工之妙。下牛顿第二定律的常见表述：物体加速度的大小跟作用力成正比，跟物体的质量成反比，且与物体质量的倒数成正比。该定律是由艾萨克·牛顿在1687年于《自然哲学的数学原理》一书中提出的。牛顿第二运动定律和第一、第三定律共同组成了牛顿运动定律，阐述了经典力学中基本的运动规律。\n\n在中学课本中，牛顿第二定律有两种设计实验的方法：倾斜滑动法和水平拉线法。 \n\n\n<center>\n \n\n\n</center>\n<center>图2：牛顿第二定律实验的两种方法</center>\n<br/>\n\n相信很多读者均有摆弄滑轮和小木块做实验的青涩年代和美好回忆。基于多次实验，统计到不同的作用力下木块加速度如下表所示。\n\n<br/>\n\n<center>表1：实验获取的大量数据样本和作图观测结果</center>\n\n<center>\n\n| 项目 | 作用力X | 加速度Y |\n| -------- | -----: | :----: |\n| 第1次 | 4 | 2 |\n| 第2次 | 5 | 2.5 |\n| ... | ... | ... |\n| 第n次 | 6 | 3 |\n\n</center>\n\n观察上述实验数据，不难猜测物体的加速度$ａ$和作用力之间的关系应该是线性关系。所以，我们提出假设 $a = w * F$，$a$代表加速度，$F$代表作用力，$ｗ$是待确定的参数。\n\n通过大量实验数据的训练，确定参数$ｗ$是物体质量的倒数$(１/m)$,即得到完整的模型公式$ａ = w * (1/m)$。当已知作用到某个物体的力时，基于模型可以方便的预测物体的加速度。例如燃料对火箭的推力$F$=10，火箭的质量$m$=2，求得火箭的加速度$a$=5。\n\n这个有趣的案例演示机器学习的基本过程，但其中有一个关键点的实现尚不清晰，即怎样确定模型的参数$（w=1/m）$？\n\n学习确定参数的过程与科学家提出假说的方式类似，合理的假说至少能够解释所有已有观测。如果在未来观测到不符合理论假说的新数据，人们会尝试提出新的假说。如天文史上，使用大圆和小圆组合的方式计算天体运行在中世纪是可以拟合观测数据的。但随着欧洲机械工业的进步，天文观测设备逐渐强大，越来越多的观测数据无法套用已有的理论。这促进了使用椭圆计算天体运行的理论假说出现。所以，模型有效的基本条件是能够拟合已知的样本，这给我们提供了学习有效模型的实现方案。以$Ｈ$为模型的假设，它是一个关于参数$\\theta$和输入$Ｘ$的函数，用$H(\\theta, X)$ 表示。模型的优化目标是使得$H(\\theta, X)$的输出与真实输入$Ｙ$尽量一致，即两者相差程度即是模型效果的评价函数（相差越小越好）。那么，学习参数的过程就是在已知的样本上，不断减小该评价函数（$H(\\theta, X)$ 和$Ｙ$相差）的过程，直到学习到一个参数$\\theta$使得评价函数的取值最小。这个衡量模型预测值和真实值差距的评价函数也被称为损失函数（损失 Loss）。上述优化参数的过程如下图公式所示。\n\n<center>\n\n\n\n</center>\n<center>图3：学习确定参数的方法</center>\n<br/>\n\n\n举例类比，机器如一个机械的学生一样，只能通过尝试答对（最小化损失）大量的习题（已知样本）来学习知识（模型参数ｗ），期望用学习到的知识ｗ组成完整的模型$H(\\theta, X)$，能回答不知道答案的考试题（未知样本）。最小化损失是模型的优化目标，实现损失最小化的方法称为优化算法，也称为寻解算法（找到使得损失函数最小的参数解）。参数$\\theta$和输入$Ｘ$组成公式的基本结构称为假设。在牛顿第二定律的案例中，基于对数据的观测，我们提出的是线性假设，即作用力和加速度是线性关系，用线性方程表示。由此可见，模型假设，评价函数（损失/优化目标）和优化算法是构成一个模型的三个部分。\n\n机器学习算法理论在上个世纪90年代发展成熟，在诸多领域也取得了应用效果。但平静的日子过到2010年左右，深度学习模型的异军突起，极大改变了机器学习的应用格局。在今天，多数机器学习任务均可以使用深度学习模型解决。在语音，计算机视觉和自然语言处理等领域，深度学习模型的效果比传统机器学习算法有显著提升。\n\n那么，深度学习又怎样对机器学习的算法结构提出了改进呢？其实两者的理论结构是一致的，也存在模型假设，评价函数和优化算法，最根本的差别在于假设的复杂度上。\n\n\n\n<center>\n \n\n\n</center>\n<center> 图4：从原始图片像素到高级语义概念“美女”的函数转换的复杂度难以想象！</center>\n<br/>\n\n如上图所示，不是所有的任务均如牛顿第二定律那样简单直观。对于一张图片，人脑接收到五颜六色的光学信号，计算机则接收到一个数字矩阵。人脑以极快的速度反应出这张图片是一位美女，而且是程序员喜欢的类型。这个结果是一个非常高级的语义概念，从像素到高级语义概念中间要经历怎样复杂的信息变换是难以想象的！这种变换已经复杂到无法用数学公式表达，所以研究者们借鉴了人脑神经元的结构，设计出神经网络的模型。\n\n人工神经网络包括多个神经网络层（卷积层、全连接层、LSTM等），每一层又包括很多神经元，超过三层的非线性神经网络都可以被成为深度神经网络。通俗的讲，深度学习的模型可以视为是输入到输出的映射函数，比如中文到英文的映射，足够深的神经网络理论上可以拟合任何复杂的函数，因此，神经网络非常适合学习样本数据的内在规律和表示层次，对文字＼图像和声音任务有很好的适用性，因为这几个领域的任务是人工智能的基础模块，所以深度学习被称为实现人工智能的基础也就不足为奇了\n\n\n# 深度学习的历史和发展\n\n究竟神经网络是怎样的设计？先不用着急，在下一章会以一个“房价预测”的案例，演示使用Python实现神经网络模型的细节。在进入实现细节之前，让我们回顾下深度学习的悠久的历史和今日的蓬勃发展。\n\n神经网络思想的提出已经是75年前的事情了，现今的神经网络和深度学习的设计理论是一步步的完善的。在这漫长的发展岁月中，有一些取得关键突破的闪光时刻。其中有1960年代，基本网络结构设计完善后的黄金时代，也有在1969年异或问题被提出后（人们惊奇的发现神经网络模型连简单的异或问题也无法解决），神经网络模型被束之高阁的黑暗时代。虽然在1986年，新提出的多层的神经网络解决了异或问题，但随着90年代后理论更完备并且实践效果更好的SVM等机器学习模型的兴起，神经网络并未得到重视。真正的兴起是在2010年左右，基于神经网络模型改进的技术在语音和计算机视觉任务上大放异彩，也逐渐被证明在更多的任务（自然语言处理以及海量数据的任务）上有效。至此，神经网络模型重新焕发生机，并有了一个更加响亮的名字：深度学习。\n\n\n<center>\n \n<img src=\"https://ai-studio-static-online.cdn.bcebos.com/3ffdc18ef6384f4b93fcba9eff5360b926e7822eb0f5452ea85163281f31b3a2\" width = \"1000\" height = \"600\" alt=\"深度学习有悠久的发展历史，但在2010年后才逐渐成熟\" align=center />\n\n</center>\n<center> 图5：深度学习有悠久的发展历史，但在2010年后才逐渐成熟 </center>\n<br/>\n\n\n为何神经网络到2010年后才焕发生机，这与深度学习成功所依赖的先决条件有关。\n\n1. 大数据是它有效的前提。神经网络和深度学习是非常强大的模型，但也需要足够量级的训练数据。时至今日，很多传统机器学习算法和人工特征依然是足够有效的方案，原因在于很多场景下没有足够的标记数据来支撑深度学习这样强大的模型。深度学习的能力特别像科学家托罗密的豪言壮语：“给我一根足够长的杠杆，我能撬动地球！”，它也可以发出类似的豪言：“给我足够多的数据，我能够学习任何复杂的关系”。但在现实中，足够长的杠杆与足够多的数据一样，往往只能是一种美好的愿景。直到近些年，各行业IT化程度提高，累积的数据量爆发式的增长，才使得应用深度学习模型成为可能。\n2. 依靠硬件的发展和算法的优化。现阶段依靠更强大的计算机，GPU，Autoencoder预训练和并行计算等技术，深度网络在训练上的困难已经被逐渐克服。其中，数据量和硬件是更主要的原因。没有前两者，科学家们想优化算法都无从进行。\n\n　　早在1998年，一些科学家就已经使用神经网络模型识别手写字母图像了。但深度学习在计算机视觉应用上的兴起，还是在2012年ImageNet比赛上，使用AlexNet做图像分类。如果比较下98年和12年的模型，会发现两者在网络结构上非常类似，仅在一些细节上有所优化。在这十四年间计算性能的大幅提升和数据量的爆发式增长，促使模型完成了从“简单的字母识别”到“复杂的图像分类”的跨越。\n\n虽然历史悠久，但深度学习在今天依然在蓬勃发展，一方面基础研究快速进展，另一方面工业实践层出不穷。\n\n如下图所示，基于深度学习的顶级会议ICLR(international conference on learning representations)统计，深度学习相关的论文数量呈逐年递增的状态。同时，不仅仅是深度学习会议，与数据和模型技术相关的会议ICML和KDD，专注视觉的CVPR和专注自然语言处理的EMNLP等国际会议的大量论文均涉及着深度学习技术。该领域和相关领域的研究方兴未艾，技术仍在不断创新突破中。\n\n<center>\n\n<img src=\"https://ai-studio-static-online.cdn.bcebos.com/098749c66df347c8b99e61156718a28ff469d69f312442638fd9e88ad93bb982\" width = \"600\" height = \"400\" alt=\"与深度学习相关的论文数量逐年攀升\" align=center />\n\n</center>\n<center>图6：与深度学习相关的论文数量逐年攀升</center>\n<br/>\n\n另一方面，以深度学习为基础的人工智能技术在升级改造众多的传统行业，存在极其广阔的应用场景。下图选自艾瑞咨询的研究报告，人工智能技术不仅可在众多行业中落地应用（广度），在部分行业（如安防）已经实现了市场化变现和高速增长（深度）。\n\n<center>\n\n<img src=\"https://ai-studio-static-online.cdn.bcebos.com/6060c5cd5f47431abb54faf47f4c5e6c4a33a210bcff470c91a47dfea5904539\" width = \"900\" height = \"700\" alt=\"以深度学习为基础的AI技术在各行业广泛应用，产生巨大经济价值\" align=center />\n\n</center>\n<center>图7：以深度学习为基础的AI技术在各行业广泛应用，产生巨大经济价值</center>\n<br/>\n\n除了应用广泛的特点外，深度学习还推动人工智能进入工业大生产阶段，算法的通用性导致标准化、自动化和模块化的框架产生。此前，不同流派的机器学习算法理论和实现均不同，导致每个算法均要独立实现，例如随机森林和支撑向量机（SVM）。但在深度学习框架下的诸多算法结构有较大的通用性，例如常用与计算机视觉的卷积神经网络模型（CNN）和常用于自然语言处理的长期短期记忆模型(LSTM)，均可以分为组网模块，梯度下降的优化模块，预测模块等。这使得抽象出统一的框架成为了可能，并大大降低了编写建模代码的成本。一些相对通用的模块，如网络基础算子的实现，各种优化算法等均可以由框架实现。建模者只需要关注数据处理，配置组网的方式，以及用少量代码串起训练和预测的流程即可。\n\n<center>\n\n\n \n</center>\n<center>图8：深度学习模型具有通用性特点，可以标准化、自动化和模块化 </center>\n<br/>\n\n在深度学习框架出现之前，机器学习工程师处于手工业作坊生产的时代。为了完成建模，工程师需要储备大量数学知识，并为特征工程工作积累大量行业知识。每个模型是极其个性化的，建模者如同手工业者一样，将自己的积累形成模型的“个性化签名”。而今，“深度学习工程师”进入了工业化大生产时代。只要掌握深度学习必要但少量的理论知识，掌握Python编程即可以在深度学习框架实现极其有效的模型，甚至与该领域最领先的实现模型不相上下。建模这个被“老科学家”们长期把持的建模领域面临着颠覆，也是新入行者的机遇。\n\n<center>\n\n<img src=\"https://ai-studio-static-online.cdn.bcebos.com/09c968080e83481cb44a5aac3bdfb9a111fcac98bb254793b975f5eb3f23ba70\" width = \"800\" height = \"600\" alt=\"深度学习工程师处于工业化大生产时代，“老科学家”长期积累的优势不再牢固\" align=center />\n\n</center>\n\n<br/>\n<center>图9：深度学习工程师处于工业化大生产时代，“老科学家”长期积累的优势不再牢固</center>\n<br/>\n\n每个人的生命都是宝贵的，我们经常说要将有限的时间浪费在有价值的事情上。为何要学习深度学习技术，以及通过这本书来学习呢？一方面，深度学习的应用前景广阔，是极好的发展方向和职业选择。另一方面，本书会使用国产的深度学习框架飞桨（PaddlePaddle）来编写实践案例，基于框架的编程让深度学习变得易学易用。\n\n下面让我们尽快开始第一个实践案例：基于Python编写完成房价预测任务的神经网络模型，并在这个过程中亲身设计一个神经网络模型。\n\n### 思考题\n1. 类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？模型假设和参数是什么？评价函数（损失）是什么？\n2. 为什么说深度学习工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？", "_____no_output_____" ] ] ]

[ "markdown" ]

[ [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "Refs:\n\nhttps://github.com/deep-learning-with-pytorch/dlwpt-code", "_____no_output_____" ] ], [ [ "import numpy as np\nimport torch", "_____no_output_____" ] ], [ [ "### Optimizers", "_____no_output_____" ] ], [ [ "x = [35.7, 55.9, 58.2, 81.9, 56.3, 48.9, 33.9, 21.8, 48.4, 60.4, 68.4]\ny = [0.5, 14.0, 15.0, 28.0, 11.0, 8.0, 3.0, -4.0, 6.0, 13.0, 21.0]\n\nx = torch.tensor(x)\ny = torch.tensor(y)\n\n#x = 0.1*x # normalize", "_____no_output_____" ], [ "x_norm = 0.1*x", "_____no_output_____" ], [ "def model(x, w, b):\n return w * x + b", "_____no_output_____" ], [ "def loss_fn(y_p, y):\n squared_diffs = (y_p - y)**2\n return squared_diffs.mean()", "_____no_output_____" ], [ "import torch.optim as optim", "_____no_output_____" ], [ "dir(optim)", "_____no_output_____" ], [ "def training_loop(n_epochs, optimizer, params, x, y):\n \n for epoch in range(1, n_epochs + 1):\n y_p = model(x, *params) \n loss = loss_fn(y_p, y)\n \n ## reset gradients to zero\n optimizer.zero_grad()\n \n ## calculate gradients\n loss.backward() \n \n ## update params: params -= learning_rate * params.grad\n optimizer.step() \n\n if epoch % 500 == 0:\n print('Epoch %d, Loss %f' % (epoch, float(loss)))\n \n return params", "_____no_output_____" ], [ "params = torch.tensor([1.0, 0.0], requires_grad=True)\n\nlearning_rate = 1e-2\noptimizer = optim.SGD([params], lr=learning_rate)\n\ntraining_loop(n_epochs = 5000, params = params,\n optimizer = optimizer, x = x_norm, y = y)", "Epoch 500, Loss 7.860115\nEpoch 1000, Loss 3.828538\nEpoch 1500, Loss 3.092191\nEpoch 2000, Loss 2.957698\nEpoch 2500, Loss 2.933134\nEpoch 3000, Loss 2.928648\nEpoch 3500, Loss 2.927830\nEpoch 4000, Loss 2.927679\nEpoch 4500, Loss 2.927652\nEpoch 5000, Loss 2.927647\n" ] ] ]

[ "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# The basic nbpy_top_tweeters app", "_____no_output_____" ], [ "First, let's get connected with the Twitter API:", "_____no_output_____" ] ], [ [ "import os\nimport tweepy", "_____no_output_____" ], [ "auth = tweepy.AppAuthHandler(\n os.environ['TWITTER_API_TOKEN'],\n os.environ['TWITTER_API_SECRET']\n)\n\napi = tweepy.API(auth)\napi", "_____no_output_____" ], [ "# import requests_cache\n# requests_cache.install_cache()", "_____no_output_____" ] ], [ [ "At this point, we use the `search()` method to get a list of tweets matching the search term:", "_____no_output_____" ] ], [ [ "nbpy_tweets = api.search('#nbpy', count=100)", "_____no_output_____" ], [ "len(nbpy_tweets)", "_____no_output_____" ] ], [ [ "From the iterable of tweets we get the number of tweets per user by using a `collections.Counter` object:", "_____no_output_____" ] ], [ [ "from collections import Counter\n\ntweet_count_by_username = Counter(tweet.user.screen_name for tweet in nbpy_tweets)", "_____no_output_____" ], [ "tweet_count_by_username", "_____no_output_____" ] ], [ [ "At this point, we can calculate the top $n$ tweeters:", "_____no_output_____" ] ], [ [ "top_tweeters = tweet_count_by_username.most_common(20)\ntop_tweeters", "_____no_output_____" ] ], [ [ "And show a scoreboard with the winners:", "_____no_output_____" ] ], [ [ "for username, tweet_count in top_tweeters:\n print(f'@{username:20}{tweet_count:2d}')", "_____no_output_____" ] ], [ [ "- We can see that, already with the \"vanilla\" notebook, we have some degree of interactivity simply by editing and running the code cell-by-cell rather than in one go", "_____no_output_____" ], [ "---", "_____no_output_____" ], [ "# From `repr()` output to rich output with `IPython.display`", "_____no_output_____" ] ], [ [ "import random\n\ntweet = random.choice(nbpy_tweets)\ntweet", "_____no_output_____" ] ], [ [ "- The repr of these objects are rich in information, but not very easy to explore", "_____no_output_____" ] ], [ [ "tweet.user", "_____no_output_____" ] ], [ [ "The `IPython.display` module contains several classes that render rich output from objects in a cell's output", "_____no_output_____" ] ], [ [ "from IPython.display import *", "_____no_output_____" ] ], [ [ "- `JSON` turns any JSON-able `dict` into an expandable, filterable widget", "_____no_output_____" ] ], [ [ "tweet._json", "_____no_output_____" ], [ "JSON(tweet._json)", "_____no_output_____" ] ], [ [ "- `Image` generates an image from raw PNG data, a file path, or a URL", "_____no_output_____" ] ], [ [ "Image(tweet.user.profile_image_url)", "_____no_output_____" ] ], [ [ "- `Markdown` can be used to generate rich text programmatically in a cell's output\n", "_____no_output_____" ] ], [ [ "Markdown(f\"\"\"\n*{tweet.user.name}* (`@{tweet.user.screen_name}`) is tweeting about **North Bay Python**!\n\"\"\")", "_____no_output_____" ] ], [ [ "- `HTML` is able to render arbitrary HTML code", "_____no_output_____" ] ], [ [ "HTML('<a class=\"twitter-timeline\" href=\"https://twitter.com/northbaypython?ref_src=twsrc%5Etfw\">Tweets by northbaypython</a> <script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>');", "_____no_output_____" ] ], [ [ "- `FileLink` generates a \"smart\" link to a file, relative to the notebook's working directory", "_____no_output_____" ] ], [ [ "FileLink('hey-nbpy.md')", "_____no_output_____" ] ], [ [ "---", "_____no_output_____" ], [ "We can use these building block to create rich representations and associate them with any object\n\n- Strategy #1: Register custom formatters for object types", "_____no_output_____" ] ], [ [ "def tweet_as_markdown(tweet):\n quoted_text = '\\n'.join(f'> {line}' for line in tweet.text.split('\\n'))\n author = f'--*{tweet.user.name}* (`@{tweet.user.screen_name}`) on {tweet.created_at}'\n return quoted_text + '\\n\\n' + author", "_____no_output_____" ], [ "formatters = get_ipython().display_formatter.formatters\nformatters['text/markdown'].for_type(tweepy.Status, tweet_as_markdown)", "_____no_output_____" ], [ "tweet", "_____no_output_____" ] ], [ [ "- Strategy #2: Implement `_repr_*_()` methods for custom classes", "_____no_output_____" ], [ "Notes:\n\n- Let's say we want to move the tweet-counting code to its own class\n", "_____no_output_____" ] ], [ [ "class ScoreBoard:\n \n def __init__(self, items, display_top=5):\n self._items = items\n self.display_top = display_top\n \n @property\n def counts_by_name(self):\n return Counter(self._items)\n \n @property\n def to_display(self):\n return self.counts_by_name.most_common(self.display_top)\n\n def _repr_markdown_(self):\n # effectively we're using this \n lines = [\n f'# [North Bay Python 2019](https://2019.northbaypython.org) Top {self.display_top} Tweeters',\n '| name | # tweets |',\n '|-|-|',\n ]\n\n for name, count in self.to_display:\n lines.append(f'| {name} | {count} |')\n\n return '\\n'.join(lines)\n ", "_____no_output_____" ], [ "ScoreBoard(tweet_count_by_username, display_top=10)", "_____no_output_____" ] ], [ [ "- Rich output is rendered automatically when the object is the return value of a cell\n - Tip: use a `;` at the end of the last line in the cell to render nothing instead\n- Use the `display()` function to show rich output from anywhere in a cell (e.g. in a loop)\n - `display()` is versatile; falls back to text repr in a console", "_____no_output_____" ] ], [ [ "for tweet in nbpy_tweets[:10]:\n display(tweet)", "_____no_output_____" ], [ "nbpy_tweets = api.search('#nbpy', count=100000)", "_____no_output_____" ], [ "import pickle\n\nwith open('nbpy_tweets.pkl', 'wb') as f:\n pickle.dump(nbpy_tweets, f)", "_____no_output_____" ], [ "with open('nbpy_tweets.pkl', 'rb') as f:\n unpickled = pickle.load(f)\n \nlen(unpickled)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Tutorial Title", "_____no_output_____" ], [ "A brief introduction to the tutorial that describes:\n\n- The problem that that the tutorial addresses\n- Who the intended audience is\n- The expected experience level of that audience with a concept or tool \n- Which environment/language it runs in \n\nIf there is another similar tutorial that's more appropriate for another audience, direct the reader there with a linked reference.", "_____no_output_____" ], [ "## How to Use This Tutorial", "_____no_output_____" ], [ "A brief explanation of how the reader can use the tutorial. Can the reader copy each code snippet into a Python or other environment? Or can the reader run `<filename>` before or after reading through the explanations to understand how the code works?", "_____no_output_____" ], [ "You can use this tutorial by *insert method(s) here*. \n\nA bulleted list of the tasks the reader will accomplish and skills he or she will learn. Begin each list item with a noun (Learn, Create, Use, etc.).\n\nYou will accomplish the following:\n\n- First task or skill\n- Second task or skill\n- X task or skill", "_____no_output_____" ], [ "## Prerequisites", "_____no_output_____" ], [ "Provide a *complete* list of the software, hardware, knowledge, and skills required to be successful using the tutorial. For each item, link the item to installation instructions, specs, or skill development tools, as appropriate. If good installation instructions aren't available for required software, start the tutorial with instructions for installing it.", "_____no_output_____" ], [ "To complete this tutorial, you need:\n\n- [MXNet](https://mxnet.incubator.apache.org/install/#overview)\n- [Language](https://mxnet.incubator.apache.org/tutorials/)\n- [Tool](https://mxnet.incubator.apache.org/api/python/index.html)\n- [Familiarity with concept or tool](https://gluon.mxnet.io/)\n", "_____no_output_____" ], [ "## The Data", "_____no_output_____" ], [ "Provide a link to where the data is hosted and explain how to download it. If it requires more than two steps, use a numbered list.", "_____no_output_____" ], [ "You can download the data used in this tutorial from the [Site Name](http://) site. To download the data:\n\n1. At the `<language>` prompt, type:\n\n `<command>`\n2. Second task.\n\n3. Last task.", "_____no_output_____" ], [ "Briefly describe key aspects of the data. If there are two or more aspects of the data that require involved discussion, use subheads (### `<Concept or Sub-component Name>`). To include a graphic, introduce it with a brief description and use the image linking tool to include it. Store the graphic in GitHub and use the following format: <img width=\"517\" alt=\"screen shot 2016-05-06 at 10 13 16 pm\" src=\"https://cloud.githubusercontent.com/assets/5545640/15089697/d6f4fca0-13d7-11e6-9331-7f94fcc7b4c6.png\">. You do not need to provide a title for your graphics. ", "_____no_output_____" ], [ "The data *add description here. (optional)*", "_____no_output_____" ], [ "## (Optional) Concept or Component Name", "_____no_output_____" ], [ "If concepts or components need further introduction, include this section. If there are two or more aspects of the concept or component that require involved discussion, use subheads (### Concept or Sub-component Name).", "_____no_output_____" ] ], [ [ "## Prepare the Data", "_____no_output_____" ] ], [ [ "If appropriate, summarize the tasks required to prepare the data, defining and explaining key concepts.", "_____no_output_____" ], [ "To prepare the data, *provide explanation here.*", "_____no_output_____" ], [ "Use a numbered procedure to explain how to prepare the data. Add code snippets or blocks that show the code that the user must type or that is used for this task in the Jupyter Notebook. To include code snippets, precede each line of code with four spaces and two tick marks. Always introduce input or output with a description or context or result, followed by a colon.", "_____no_output_____" ], [ "To prepare the data:\n\n1.\n\n2.\n\n3.", "_____no_output_____" ], [ "If there are any aspects of data preparation that require elaboration, add it here.", "_____no_output_____" ], [ "## Create the Model", "_____no_output_____" ], [ "If appropriate, summarize the tasks required to create the model, defining and explaining key concepts.", "_____no_output_____" ], [ "To create the model, *provide explanation here.*", "_____no_output_____" ], [ "Use a numbered procedure to explain how to create the data. Add code snippets or blocks that show the code that the user must type or that is used for this task in the Jupyter Notebook. To include code snippets, precede each line of code with four spaces and two tick marks. Always introduce input or output with a description or context or result, followed by a colon.", "_____no_output_____" ], [ "To create the model:\n\n1.\n\n2.\n\n3.", "_____no_output_____" ], [ "If there are any aspects of model creation that require elaboration, add it here.", "_____no_output_____" ], [ "## Fit the Model", "_____no_output_____" ], [ "If appropriate, summarize the tasks required to create the model, defining and explaining key concepts.", "_____no_output_____" ], [ "To fit the model, *provide explanation here.*", "_____no_output_____" ], [ "Use a numbered procedure to explain how to fit the model. Add code snippets or blocks that show the code that the user must type or that is used for this task in the Jupyter Notebook. To include code snippets, precede each line of code with four spaces and two tick marks. Always introduce input or output with a description or context or result, followed by a colon.", "_____no_output_____" ], [ "To fit the model:\n\n1.\n\n2.\n\n3.", "_____no_output_____" ], [ "If there are any aspects of model fitting that require elaboration, add it here.", "_____no_output_____" ], [ "## Evaluate the Model", "_____no_output_____" ], [ "If appropriate, summarize the tasks required to evaluate the model, defining and explaining key concepts.", "_____no_output_____" ], [ "To evaluate the model, *provide explanation here.*", "_____no_output_____" ], [ "Use a numbered procedure to explain how to evaluate the model. Add code snippets or blocks that show the code that the user must type or that is used for this task in the Jupyter Notebook. To include code snippets, precede each line of code with four spaces and two tick marks. Always introduce input or output with a description or context or result, followed by a colon.", "_____no_output_____" ], [ "To evaluate the model:\n\n1.\n\n2.\n\n3.", "_____no_output_____" ], [ "If there are any aspects of model evaluation that require elaboration, add it here.", "_____no_output_____" ], [ "## (Optional) Additional Tasks", "_____no_output_____" ], [ "If appropriate, summarize the tasks required to perform the task, defining and explaining key concepts.", "_____no_output_____" ], [ "To *fperform the task*, *provide explanation here.*", "_____no_output_____" ], [ "Use a numbered procedure to explain how to perform the task. Add code snippets or blocks that show the code that the user must type or that is used for this task in the Jupyter Notebook. To include code snippets, precede each line of code with four spaces and two tick marks. Always introduce input or output with a description or context or result, followed by a colon.", "_____no_output_____" ], [ "To *perform the task*:\n\n1.\n\n2.\n\n3.", "_____no_output_____" ], [ "If there are any aspects of model evaluation that require elaboration, add it here.", "_____no_output_____" ], [ "## Summary", "_____no_output_____" ], [ "Briefly describe the end result of the tutorial and how the user can use it or modify it to customize it.", "_____no_output_____" ], [ "## Next Steps", "_____no_output_____" ], [ "Provide a bulleted list of other documents, tools, or tutorials that further explain the concepts discussed in this tutorial or build on this tutorial. Start each list item with a brief description of a user task followed by the title of the destination site or topic that is formatted as a link.", "_____no_output_____" ], [ "- For more information on *topic*, see [Site Name](http://).\n- To learn more about using *tool or task*, see [Topic Title](http://).\n- To experiment with *service*, *tool*, or *object*, see [Site Name](http://).\n- For a more advanced tutorial on *subject*, see [Tutorial Title](http://).", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "0BSD" ]

[ "ISC" ]

[ "ISC" ]

[ [ [ "# Navigation functionality\n\nThe Navigation functionality (`veneer.navigation`) lets you query and modify the current Source model using normal Python object notation. For example:\n\n```\nscenario.Network.Nodes[0].Name = 'Renamed node'\n```\n\nThis notebook introduces the navigation functionality, including how it ties into the existing functionality in `v.model` as well as current limitations.", "_____no_output_____" ], [ "## Setup\n\nStart up Veneer as per usual...", "_____no_output_____" ] ], [ [ "import veneer\nv = veneer.Veneer(19876)", "_____no_output_____" ], [ "v.status()", "_____no_output_____" ] ], [ [ "## Initialise a Queryable object\n\n`Queryable` is the main component in `veneer.navigate`. By default, a Queryable points to the scenario.", "_____no_output_____" ] ], [ [ "from veneer.navigate import Queryable", "_____no_output_____" ], [ "scenario = Queryable(v)", "_____no_output_____" ], [ "scenario.Name", "_____no_output_____" ] ], [ [ "## Tab completion\n\n`Queryable` objects work with the tab completion in IPython/Jupyter, including, in many cases, for nested objects:\n\n", "_____no_output_____" ] ], [ [ "scenario.Network.nodes.Count", "_____no_output_____" ] ], [ [ "... However this won't work after indexing into a list or dictionary:\n\n\n\nYou can still access the properties of the list item, if you know what they're called:", "_____no_output_____" ] ], [ [ "scenario.Network.nodes[0].Name", "_____no_output_____" ] ], [ [ "... But if you want tab completion, create a variable **and run the cell that creates it**. Then tab into the new variable:\n\n", "_____no_output_____" ] ], [ [ "node = scenario.Network.nodes[0]\n# node.<tab> WON'T WORK YET. You need to run this cell first", "_____no_output_____" ], [ "# Now tab completion should work should work\nnode.Name", "_____no_output_____" ] ], [ [ "## Accessing a particular node/link/fu/etc\n\nThe above examples start from the scenario - which works, but is tedious when you need a particular node or link (or all water users, etc).\n\nHere, the existing functionality under `v.model` is has been expanded to return Queryable objects that can be used for object navigation.\n\nAll of the relevant `v.model` areas (link, node, catchment, etc) now have a `nav_first` method, which accepts the same query parameters as the other operations. For example, `v.model.node.nav_first` accepts the `nodes` and `node_types` query parameters, in the same way as `v.model.node.get_param_values`.\n\nAs always, the query parameters are available in the help, one level up:\n", "_____no_output_____" ] ], [ [ "v.model.node?", "_____no_output_____" ] ], [ [ "... So we can get a particular node, for navigation as follows.", "_____no_output_____" ] ], [ [ "callide = v.model.node.nav_first(nodes='Callide Dam')", "_____no_output_____" ] ], [ [ "**Note:** The function is called `nav_first` to emphasise that you will receive the **first** match for the query. So, if you query `node_types='WaterUser'`, you'll get the first Water User matched.\n\nIt's likely that we'll add a more generic `nav` method at some point that allows you to get a Queryable capable of bulk operations.", "_____no_output_____" ], [ "## Working with the navigation object\n\nFrom the examples above, it looks like, you can work with the `Queryable` object as a normal Python object. In *some* cases you can, but not always.\n\nFor changing values in the object (ie changing the relevant property in the Source model), you can indeed set the value directly:", "_____no_output_____" ] ], [ [ "callide.Name", "_____no_output_____" ], [ "callide.fullSupplyLevel", "_____no_output_____" ], [ "callide.fullSupplyVolume", "_____no_output_____" ], [ "callide.fullSupplyVolume = 136300000", "_____no_output_____" ], [ "callide.fullSupplyVolume", "_____no_output_____" ] ], [ [ "**Note:** Changing one thing may have a side effect, impacting another property:", "_____no_output_____" ] ], [ [ "callide.fullSupplyLevel", "_____no_output_____" ] ], [ [ "If a property can't be set this way, it *should* tell you:", "_____no_output_____" ] ], [ [ "# CAUSES EXCEPTION\n#callide.fullSupplyLevel = 216", "_____no_output_____" ] ], [ [ "### Things aren't necessarily as they seem!\n\nThe above examples suggest that the following would work:", "_____no_output_____" ] ], [ [ "# Would be nice, but doesn't work...\n#callide.fullSupplyVolume = 1.1 * callide.fullSupplyVolume", "_____no_output_____" ] ], [ [ "The reason is, `callide.fullSupplyVolume` is, itself, a `Queryable` object:", "_____no_output_____" ] ], [ [ "callide.fullSupplyVolume.__class__", "_____no_output_____" ] ], [ [ "So, although it prints out as a number, it is in fact a reference to the value within the model.\n\nIf you want to actually use the *value* in an expression (eg to set another property), you'll need to use the `", "_____no_output_____" ] ], [ [ "callide.fullSupplyVolume = 1.1 * callide.fullSupplyVolume._eval_()", "_____no_output_____" ], [ "callide.fullSupplyVolume", "_____no_output_____" ], [ "callide.fullSupplyVolume = callide.fullSupplyVolume._eval_() / 1.1", "_____no_output_____" ], [ "callide.fullSupplyVolume", "_____no_output_____" ] ], [ [ "## Evaluating a Queryable\n\nIt's not ideal to need to call `._eval_()` and we plan to improve this over time.\n\nAlso, the `_eval_()` workaround only works for simple types - numbers, strings, booleans, etc. It doesn't work for complex objects, such as Nodes, Links and model instances.\n\nFor example you CANNOT do this at the moment:\n\n```\nstorage = v.model.node.nav_first(nodes='my storage')\nlink = v.model.link.nav_first(links='some link')\n\n# Try to set the outlet link for the storage...\nstorage.OutletPaths[0] = link # WILL NOT WORK!\n```\n", "_____no_output_____" ], [ "## Bulk changes\n\nWhen you use the model configuration functionality under `v.model` every operation is a **bulk** operation by default - you use query parameters to limit the application:\n\nFor example, the following would retrieve Easting and Northing (really, just the node coordinates) for every node:\n\n```\neastings = v.model.node.get_param_values('Node.location.E')\nnorthings = v.model.node.get_param_values('Node.location.N')\n```\n\nwhile the following would do the same for only storages, by using query parameters:\n\n```\neastings = v.model.node.get_param_values('Node.location.E',node_types='Storage')\nnorthings = v.model.node.get_param_values('Node.location.N',node_types='Storage')\n```\n\nWhen using `Queryable`, everything is, currently, an operation on a single object (eg a single node):", "_____no_output_____" ] ], [ [ "callide.Node.location.E", "_____no_output_____" ] ], [ [ "However... one of the big benefits of the navigable functionality is the ability to discover the parameter name (often nested) that you need to use in a bulk operation.\n\n**When stuck for a parameter name, use a Queryable to discover it, through tab-completion and then plug the resulting path back into the `v.model.X.get_param_values()` call**", "_____no_output_____" ], [ "## TODO\n\nThe Queryable approach is new and will expand.\n\nThings on the list are:\n\n* Ability to call methods on Queryable objects\n* Ability to use Queryable objects in expressions, assignments to other Queryables and as method parameters\n* Ability to perform bulk operations using Queryables\n* Ability to write Python loops / list comprehensions that iterate over Source collections\n\nOther related functionality that would be nice:\n\n* Ability to identify functions, data sources, etc that point at a given variable. Eg instead of seeing `node.Inflow = 0`, see the data source that is connected.\n", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "## Generate a SWOT swath.\n\nThis example lets us understand how to initialize the simulation parameters (error, SSH interpolation, orbit), generate an orbit, generate a swath, interpolate the SSH, and simulate the measurement errors. Finally, we visualize the simulated data.\n\n### Simulation setup\n\nThe configuration is defined using an associative dictionary between the expected parameters and the values of its parameters. The description of the parameters is available on the [online help](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.settings.Parameters.html#swot_simulator.settings.Parameters).\n\nThis array can be loaded from a Python file using the [eval_config_file](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.settings.eval_config_file.html#swot_simulator.settings.eval_config_file) method. But it can also be declared directly in Python code.", "_____no_output_____" ] ], [ [ "import swot_simulator", "_____no_output_____" ], [ "configuration = dict(\n # The swath contains in its centre a central pixel divided in two by the\n # reference ground track.\n central_pixel=True,\n # Distance, in km, between two points along track direction.\n delta_al=2.0,\n # Distance, in km, between two points across track direction.\n delta_ac=2.0,\n # Distance, in km, between the nadir and the center of the first pixel of the\n # swath\n half_gap=2.0,\n # Distance, in km, between the nadir and the center of the last pixel of the\n # swath\n half_swath=70.0,\n # Limits of SWOT swath requirements. Measurements outside the span will be\n # set with fill values.\n requirement_bounds=[10, 60],\n # Ephemeris file to read containing the satellite's orbit.\n ephemeris=swot_simulator.DATA.joinpath(\n \"ephemeris_calval_june2015_ell.txt\"),\n # Generation of measurement noise.\n noise=[\n 'altimeter',\n 'baseline_dilation',\n 'karin',\n 'roll_phase',\n #'orbital', (This generator consumes too much memory to run with binder)\n 'timing',\n 'wet_troposphere',\n ],\n # File containing spectrum of instrument error\n error_spectrum=swot_simulator.DATA.joinpath(\"error_spectrum.nc\"),\n # KaRIN file containing spectrum for several SWH\n karin_noise=swot_simulator.DATA.joinpath(\"karin_noise_v2.nc\"),\n # The plug-in handling the SSH interpolation under the satellite swath.\n #ssh_plugin = TODO\n)", "_____no_output_____" ] ], [ [ "We create the parameter object for our simulation.", "_____no_output_____" ] ], [ [ "import swot_simulator.settings\n\nparameters = swot_simulator.settings.Parameters(configuration)", "_____no_output_____" ] ], [ [ "---\n**Note**\n\nThe [Parameter](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.settings.Parameters.html#swot_simulator.settings.Parameters) class exposes the [load_default](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.settings.Parameters.load_default.html#swot_simulator.settings.Parameters.load_default) method returning the default parameters of the simulation:\n\n```python\nparameters = swot_simulator.settings.Parameters.load_default()\n```\n\nIt is also possible to [automatically load the\ndictionary](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.settings.template.html)\ncontaining the simulation parameters to adapt them to your needs and after all\ncreate the parameters of your simulation.\n\n```python\nconfiguration = swot_simulator.settings.template(python=True)\nparameters = swot_simulator.settings.Parameters(configuration)\n```\n---", "_____no_output_____" ], [ "### SSH interpolation\n\nThe written configuration allows us to simulate a swath. However, the interpolation of the SSH under the satellite swath remains undefined. If you don't need this parameter, you can skip this setting.\n\nFor our example, we use the SSH of the CMEMS grids provided on the Pangeo site.", "_____no_output_____" ] ], [ [ "import intake\n\ncat = intake.open_catalog(\"https://raw.githubusercontent.com/pangeo-data/\"\n \"pangeo-datastore/master/intake-catalogs/master.yaml\")", "_____no_output_____" ], [ "ds = cat.ocean.sea_surface_height.to_dask()\nds", "_____no_output_____" ] ], [ [ "To interpolate SSH, we need to implement a class that must define a method to\ninterpolate the data under the swath. This class must be derived from the\n[CartesianGridHandler](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.plugins.data_handler.CartesianGridHandler.html)\nclass to be correctly taken into account by the class managing the parameters.", "_____no_output_____" ] ], [ [ "import pyinterp.backends.xarray\nimport numpy\nimport xarray\n#\nimport swot_simulator.plugins.data_handler\n\n\nclass CMEMS(swot_simulator.plugins.data_handler.CartesianGridHandler):\n \"\"\"\n Interpolation of the SSH AVISO (CMEMS L4 products).\n \"\"\"\n def __init__(self, adt):\n self.adt = adt\n ts = adt.time.data\n\n assert numpy.all(ts[:-1] <= ts[1:])\n\n # The frequency between the grids must be constant.\n frequency = set(numpy.diff(ts.astype(\"datetime64[s]\").astype(\"int64\")))\n if len(frequency) != 1:\n raise RuntimeError(\n \"Time series does not have a constant step between two \"\n f\"grids: {frequency} seconds\")\n\n # The frequency is stored in order to load the grids required to\n # interpolate the SSH.\n self.dt = numpy.timedelta64(frequency.pop(), 'ns')\n\n def load_dataset(self, first_date, last_date):\n \"\"\"Loads the 3D cube describing the SSH in time and space.\"\"\"\n if first_date < self.adt.time[0] or last_date > self.adt.time[-1]:\n raise IndexError(\n f\"period [{first_date}, {last_date}] is out of range: \"\n f\"[{self.adt.time[0]}, {self.adt.time[-1]}]\")\n first_date = self.adt.time.sel(time=first_date, method='pad')\n last_date = self.adt.time.sel(time=last_date, method='backfill')\n selected = self.adt.loc[dict(time=slice(first_date, last_date))]\n selected = selected.compute()\n return pyinterp.backends.xarray.Grid3D(selected.adt)\n\n def interpolate(self, lon, lat, time):\n \"\"\"Interpolate the SSH to the required coordinates\"\"\"\n interpolator = self.load_dataset(time.min(), time.max())\n ssh = interpolator.trivariate(dict(longitude=lon,\n latitude=lat,\n time=time),\n interpolator='bilinear')\n return ssh", "_____no_output_____" ] ], [ [ "Now we can update our parameters.", "_____no_output_____" ] ], [ [ "parameters.ssh_plugin = CMEMS(ds)", "_____no_output_____" ] ], [ [ "### Initiating orbit propagator.\n\nInitialization is simply done by [loading](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.orbit_propagator.load_ephemeris.html#swot_simulator.orbit_propagator.load_ephemeris) the ephemeris file. The satellite's one-day pass is taken into account in this case.", "_____no_output_____" ] ], [ [ "import swot_simulator.orbit_propagator\n\n\nwith open(parameters.ephemeris, \"r\") as stream:\n orbit = swot_simulator.orbit_propagator.calculate_orbit(parameters, stream)", "_____no_output_____" ] ], [ [ "### Iterate on the half-orbits of a period.\n\nTo iterate over all the half-orbits of a period, call the method [iterate](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.orbit_propagator.Orbit.iterate.html#swot_simulator.orbit_propagator.Orbit.iterate). This method returns all cycle numbers, trace numbers, and start dates of the half orbits within the period. If the start date remains not set, the method uses the current date. If the end date remains undefined, the method sets the end date to the start date plus the cycle duration.\n\nIn our case, we generate a cycle from January 1, 2000.", "_____no_output_____" ] ], [ [ "first_date = numpy.datetime64(\"2000-01-01\")\niterator = orbit.iterate(first_date)\ncycle_number, pass_number, date = next(iterator)\ncycle_number, pass_number, date", "_____no_output_____" ] ], [ [ "### Initialization of measurement error generators\n\nError initialization is done simply by calling the appropriate [class](https://swot-simulator.readthedocs.io/en/latest/generated/swot_simulator.error.generator.Generator.html#swot_simulator.error.generator.Generator). The initialization of the wet troposphere error generator takes a little time (about 40 seconds), which explains the processing time for the next cell.", "_____no_output_____" ] ], [ [ "import swot_simulator.error.generator\n\nerror_generator = swot_simulator.error.generator.Generator(\n parameters, first_date, orbit.orbit_duration())", "_____no_output_____" ] ], [ [ "### Generate the positions under the swath.\n\nTo perform this task, the following function is implemented.\n\n> If the position of the pass is outside the area of interest (`parameters.area`),\n> the generation of the pass can return `None`.", "_____no_output_____" ] ], [ [ "def generate_one_track(pass_number, date, orbit):\n # Compute the spatial/temporal position of the satellite\n track = swot_simulator.orbit_propagator.calculate_pass(\n pass_number, orbit, parameters)\n\n # If the pass is not located in the area of interest (parameter.area)\n # the result of the generation can be null.\n if track is None:\n return None\n\n # Set the simulated date\n track.set_simulated_date(date)\n\n return track", "_____no_output_____" ] ], [ [ "### Interpolate SSH\n\nInterpolation of the SSH for the space-time coordinates generated by the simulator.", "_____no_output_____" ] ], [ [ "def interpolate_ssh(parameters, track):\n swath_time = numpy.repeat(track.time, track.lon.shape[1]).reshape(track.lon.shape)\n ssh = parameters.ssh_plugin.interpolate(track.lon.flatten(),\n track.lat.flatten(),\n swath_time.flatten())\n return ssh.reshape(track.lon.shape)", "_____no_output_____" ] ], [ [ "### Calculation of instrumental errors\n\nSimulation of instrumental errors. \n\n> Karin's instrumental noise can be modulated by wave heights.\n> The parameter SWH takes either a constant or a matrix defining\n> the SWH for the swath positions. ", "_____no_output_____" ] ], [ [ "def generate_instrumental_errors(error_generator, cycle_number, pass_number,\n orbit, track):\n return error_generator.generate(cycle_number,\n pass_number,\n orbit.curvilinear_distance,\n track.time,\n track.x_al,\n track.x_ac,\n swh=2.0)", "_____no_output_____" ] ], [ [ "### Calculates the sum of the simulated errors.", "_____no_output_____" ] ], [ [ "def sum_error(errors, swath=True):\n \"\"\"Calculate the sum of errors\"\"\"\n dims = 2 if swath else 1\n return numpy.add.reduce(\n [item for item in errors.values() if len(item.shape) == dims])", "_____no_output_____" ] ], [ [ " ### Create the swath dataset\n \n Generation of the simulated swath. The function returns an xarray dataset for the half-orbit generated.", "_____no_output_____" ] ], [ [ "import swot_simulator.netcdf\n\n\ndef generate_dataset(cycle_number,\n pass_number,\n track,\n ssh,\n noise_errors,\n complete_product=False):\n product = swot_simulator.netcdf.Swath(track, central_pixel=True)\n # Mask to set the measurements outside the requirements of the mission to\n # NaN.\n mask = track.mask()\n ssh *= mask\n product.ssh(ssh + sum_error(noise_errors))\n product.simulated_true_ssh(ssh)\n for error in noise_errors.values():\n # Only the swaths must be masked\n if len(error.shape) == 2:\n error *= mask\n product.update_noise_errors(noise_errors)\n return product.to_xarray(cycle_number, pass_number, complete_product)", "_____no_output_____" ] ], [ [ "### Swath generation.\n\nNow we can combine the different components to generate the swath.", "_____no_output_____" ] ], [ [ "import dask\nimport dask.distributed\n\n\ndef generate_swath(cycle_number, pass_number, date, parameters,\n error_generator, orbit):\n client = dask.distributed.get_client()\n # Scatter big data\n orbit_ = client.scatter(orbit)\n error_generator_ = client.scatter(error_generator)\n # Compute swath positions\n track = dask.delayed(generate_one_track)(pass_number, date, orbit_)\n # Interpolate SSH\n ssh = dask.delayed(interpolate_ssh)(parameters, track)\n # Simulate instrumental errors\n noise_errors = dask.delayed(generate_instrumental_errors)(error_generator_,\n cycle_number,\n pass_number,\n orbit_, track)\n # Finally generate the dataset\n return dask.delayed(generate_dataset)(\n cycle_number, pass_number, track, ssh, noise_errors,\n parameters.complete_product).compute()", "_____no_output_____" ] ], [ [ "The simulator calculation can be distributed on a Dask cluster.", "_____no_output_____" ] ], [ [ "import dask.distributed\n\n# A local cluster is used here.\ncluster = dask.distributed.LocalCluster()\nclient = dask.distributed.Client(cluster)\nclient", "_____no_output_____" ], [ "error_generator_ = client.scatter(error_generator)\nparameters_ = client.scatter(parameters)\norbit_ = client.scatter(orbit)", "_____no_output_____" ], [ "future = client.submit(generate_swath, cycle_number, pass_number, date,\n parameters_, error_generator_, orbit_)\nds = client.gather(future)\nds", "_____no_output_____" ] ], [ [ "To calculate a trace set you can use the following code\n\n futures = []\n for cycle_number, pass_number, date in iterator:\n futures.append(client.submit(generate_swath,\n cycle_number,\n pass_number,\n date,\n error_generator_,\n orbit_,\n parameters))\n client.gather(futures)\n \n### Visualization", "_____no_output_____" ] ], [ [ "import matplotlib.pyplot\nimport cartopy.crs\nimport cartopy.feature\n%matplotlib inline", "_____no_output_____" ] ], [ [ "Selection of a reduced geographical area for visualization.", "_____no_output_____" ] ], [ [ "selected = ds.where((ds.latitude > -50) & (ds.latitude < -40), drop=True)", "_____no_output_____" ] ], [ [ "Simulated SSH measurements (Interpolated SSH and simulated instrumental errors).", "_____no_output_____" ] ], [ [ "fig = matplotlib.pyplot.figure(figsize=(24, 12))\nax = fig.add_subplot(1, 1, 1, projection=cartopy.crs.PlateCarree())\ncontourf = ax.contourf(selected.longitude,\n selected.latitude,\n selected.ssh_karin,\n transform=cartopy.crs.PlateCarree(),\n levels=255,\n cmap='jet')\nfig.colorbar(contourf, orientation='vertical')\nax.set_extent([60, 69, -50, -40], crs=cartopy.crs.PlateCarree())\nax.gridlines(draw_labels=True, dms=True, x_inline=False, y_inline=False)\nax.coastlines()", "_____no_output_____" ] ], [ [ "Simulated KaRIN instrumental noise.", "_____no_output_____" ] ], [ [ "for item in selected.variables:\n if item.startswith(\"simulated_error\"):\n variable = selected.variables[item]\n fig = matplotlib.pyplot.figure(figsize=(18, 8))\n ax = fig.add_subplot(1, 1, 1)\n image = ax.imshow(variable.T,\n extent=[0, len(selected.num_lines), -70, 70],\n cmap='jet')\n ax.set_title(variable.attrs['long_name'] + \"(\" +\n variable.attrs['units'] + \")\")\n ax.set_xlabel(\"num_lines\")\n ax.set_ylabel(\"num_pixels\")\n fig.colorbar(image,\n orientation='vertical',\n fraction=0.046 * 70 / 250,\n pad=0.04)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# 데이터 과학과 파이썬", "_____no_output_____" ], [ "**감사의 말**: [SciPy Lecture Notes](https://scipy-lectures.org/_downloads/ScipyLectures-simple.pdf)의 1장 내용을 참고합니다. ", "_____no_output_____" ], [ "## 파이썬", "_____no_output_____" ], [ "데이터 과학자는 보통 다음 세 가지를 필요로 한다.\n\n* 데이터 구하기: 모의 실험\n* 데이터 처리: 데이터로부터 정보 얻기\n* 데이터 시각화: 얻어진 정보 이해 및 전달", "_____no_output_____" ], [ "파이썬의 장점은 다음과 같다.\n\n* 수치 계산, 데이터 처리 및 시각화와 관련된 많고 다양한 툴을 제공한다.\n* 배우고 사용하기 쉽다.\n* 문법이 단순하다.\n* 효율적인 코드를 작성하기 쉽다.\n* 데이터 분석 이외에 프로그래밍 관련 모든 분야에서 사용된다.", "_____no_output_____" ], [ "## 파이썬 대 기타 언어", "_____no_output_____" ], [ "**컴파일 언어**\n\nC, C++, C#, 자바 등 작성된 코드를 컴파일<font size=\"2\">compile</font>한 후에 실행하도록 하는 \n컴파일 언어<font size=\"2\">compiled language</font>의\n장점과 단점은 다음과 같다.\n\n* 장점\n * 실행이 매우 빠르다. 따라서 매우 많은 양의 계산에 적합하다.\n* 단점\n * 사용하기 어렵다. 메모리 수동 관리, 복잡한 구문 등 일반 사용자가 접근하기에는 \n 조금 어려운 프로그래밍 언어이다.", "_____no_output_____" ], [ "**매트랩**<font size=\"2\">Matlab</font>\n\n* 장점\n * 다양한 분야에서 활용될 수 있는 효율적인 수치 계산용 알고리즘을 포함하는 라이브러리를 제공한다.\n * 편리한 개발환경을 제공한다.\n * (유료) 기술 지원이 제공된다.\n* 단점\n * 언어 자체가 고수준의 기능을 지원하지 않는다.\n * 유료.", "_____no_output_____" ], [ "**R**\n\n* 장점\n * 오픈 소스<font size=\"2\">open source</font>이며 무료.\n * 통계 관련 고수준의 기능을 지원한다.\n \n* 단점\n * 매트랩보다 지원되는 알고리즘이 적으며, 언어 자체도 고수준의 기능을 제대로 지원하지 않는다.\n * 지원되는 기능도 제한적인 영역에서만 활용되어 보편성이 떨어진다.", "_____no_output_____" ], [ "**파이썬**\n\n* 장점\n * 계산 관련 라이브러리가 풍부하다.\n * 체계적이며 가독성이 높은 코드 작성을 지원한다.\n * 웹서버 등 계산 과학 이외의 기타 분야에서도 활용되는 라이브러리를 지원한다.\n * 오픈 소스이자 무료이고 많은 사용자 그룹이 존재한다.\n * 다양한 개발환경이 지원된다.\n * [IPython](http://ipython.readthedocs.io/en/stable/)\n * [Spyder](https://www.spyder-ide.org/)\n * [Jupyter notebooks](http://jupyter.org/)\n * [Visual Studio Code](https://code.visualstudio.com/docs/languages/python)\n \n* 단점\n * 컴파일 언어로 작성된 프로그램에 비해 상대적으로 느리게 작동한다.\n * 시스템 개발 등에 사용되기에는 제한적이다.", "_____no_output_____" ], [ "## 데이터 과학용 파이썬 생태계", "_____no_output_____" ], [ "매트랩과 R은 수치계산 또는 통계 분석에 특화된 프로그래밍 언어이다.\n반면에 파이썬은 모든 영역의 문제를 해결하는 데에 사용되는 \n범용<font size=\"2\">universal</font> 프로그래밍 언어이다.\n데이터 과학용으로 파이썬을 사용할 때 사용되는 기본 구성요소는 다음과 같다.", "_____no_output_____" ], [ "**파이썬 기본 패키지**\n\n- 파이썬 프로그래밍 언어 기본: 변수, 표현식, 함수, 클래스, 모듈, 명령문 등등\n- 기본 자료구조: 정수(`int`), 부동소수점(`float`), 문자열(`string`), \n 리스트(`list`), 튜플(`tuple`), 사전(`dict`), 집합(`set`) 등등\n- 웹 프로그래밍, 계산 과학 등 다양한 분야에 특화된 모듈 및 라이브러리\n- 테스트 자동화, 문서 생성 등의 개발툴", "_____no_output_____" ], [ "**NumPy(넘파이) 패키지**\n\n- 수치 계산 전용 라이브러리, 특히 행렬 연산에 효율적임. \n- 참고: [http://www.numpy.org/](http://www.numpy.org/)", "_____no_output_____" ], [ "**Scipy(싸이파이) 패키지**\n\n- 최적화<font size=\"2\">optimization</font>, \n회귀 분석<font size=\"2\">regression analysis</font>, \n보간법<font size=\"2\">interpolation</font> 등등과 관련된 고수준 라이브러리\n- 참고: [http://www.scipy.org/](http://www.scipy.org/)", "_____no_output_____" ], [ "**Matplotlib(맷플롯립) 패키지**\n\n- 2D 시각화\n- 참고: [http://matplotlib.org/](http://matplotlib.org/)\n <br>\n\n<div align=\"center\"><img src=\"https://github.com/codingalzi/pyfast/blob/master/notebooks/images/random_c.jpg?raw=true\" width=\"60%\"></div>", "_____no_output_____" ], [ "**대화식<font size=\"2\">interactive</font> 개발환경**\n\n* **IPython**: 개선된 파이썬 콘솔([http://ipython.org/](http://ipython.org/))\n <br>\n\n <div align=\"center\"><img src=\"https://github.com/codingalzi/pyfast/blob/master/notebooks/images/snapshot_ipython.png?raw=true\" width=\"50%\"></div>", "_____no_output_____" ], [ "* **Jupyter notebooks**: 웹 브라우저 활용 파이썬 프로그래밍 인터페이스([http://jupyter.org/](http://jupyter.org/))\n <br>\n\n <div align=\"center\"><img src=\"https://jupyter.org/assets/homepage/jupyterpreview.webp\" width=\"50%\"></div>", "_____no_output_____" ], [ "**도메인 특화 패키지**", "_____no_output_____" ], [ "* **pandas**, **statsmodels**, **seaborn**: 통계", "_____no_output_____" ], [ "* **sympy**: 기호 계산<font size=\"2\">symbolic computing</font>", "_____no_output_____" ], [ "* **scikit-image**: 이미지 처리", "_____no_output_____" ], [ "* **scikit-learn**: 머신러닝", "_____no_output_____" ], [ "* **tensorflow**, **pytorch**: 딥러닝", "_____no_output_____" ], [ "* **mayavi**: 3D 시각화\n\n <div align=\"center\"><img src=\"https://github.com/codingalzi/pyfast/blob/master/notebooks/images/example_surface_from_irregular_data.jpg?raw=true\" width=\"50%\"></div>", "_____no_output_____" ], [ "## 데이터 과학용 파이썬 설치 및 개발환경", "_____no_output_____" ], [ "### 파이썬 설치", "_____no_output_____" ], [ "앞서 언급된 라이브러리 중에 mayavi를 제외한 모든 것을\n한 번에 설치하는 패키지로 **아나콘다**<font size=\"2\">Anaconda</font>를 추천한다.", "_____no_output_____" ], [ "### 개발 환경", "_____no_output_____" ], [ "**대화식 프로그래밍**\n\n간단한 파이썬 코딩 설명을 위해서 대화식 프로그래밍<font size=\"2\">interactive programming</font>을\n지원하는 \n주피터 노트북<font size=\"2\">Jupyter notebook</font>을 기본적으로 사용한다.\n주피터 노트북은 \n파이썬의 기본 콘솔의 기능을 확장한 IPython 콘솔을 포함한다.\n\n파이썬 기본 콘솔은 다음 모양의 대화식 코딩을 지원하는다.\n\n```python\n>>> print('Hello world')\nHello world\n```\n\n반면에 IPython 콘솔의 대화식 코딩은 다음과 같다.\n\n```python\nIn [1]: print('Hello world')\nHello world\n```\n\nIPython 콘솔은 이외에 아래에서 설명하는 매직 커맨드 보다\n유용한 기능을 지원한다.", "_____no_output_____" ], [ ":::{admonition} 아나콘다 설치와 주피터 노트북 사용법\n:class: tip\n\n[나도코딩의 동영상](https://www.youtube.com/watch?v=dJfq-eCi7KI&t=2298s)에서 아나콘다의 설치 과정과\n주피터 노트북의 기초 사용법에 대한 상세한 설명을 들을 수 있다.\n:::\n", "_____no_output_____" ], [ "**IDE(통합 개발 환경)**", "_____no_output_____" ], [ "보다 복잡한 파이썬 코딩을 위해서는 코드 편집과 실행, 디버깅 등 \n프로그래밍 관련 모든 작업을 통합해서 지원하는 \n통합 개발 환경을 사용한다.\n\n일명 **IDE**<font size=\"2\">Interactive Development Environment</font>라고 불리는\n통합 개발 환경을 지원하는 다양한 툴이 존재하며, \n대표적으로 다음과 같다.\n\n* [Spyder](https://www.spyderide.org/): 아나콘다 패키지에 포함되어 있다.\n* [PyCharm](https://www.jetbrains.com/pycharm): 가장 인기있는 상용 프로그램이다.\n Pro 와 Community 두 버전을 지원하며 무료 버전인 Community 만으로도 입문용으로 충분하다.\n* [Visual Studio Code](https://code.visualstudio.com/docs/languages/python): \n 마이크로소프트에서 지원하며, 현재 가장 인기 있는 무료 프로그램이다. \n 파이썬 뿐만 아니라 거의 모든 프로그래밍 언어를 위한 통합 개발 환경을 지원한다.\n* [Atom](https://atom.io): 소스코드 저장소로 가장 유명한 \n [GitHub](https://github.com/)에서 개발한 IDE. \n Visual Studio Code 처럼 거의 모든 프로그래밍 언어를 지원한다.", "_____no_output_____" ], [ "여기서는 일명 **VS Code**라 불리는 \n비주얼 스튜디오 코드<font size=\"2\">Visual Studio Code</font>를 사용할 것을 추천한다.", "_____no_output_____" ], [ ":::{admonition} VS Code 설치와 사용법\n:class: tip\n\n[생활코딩의 동영상](https://www.youtube.com/watch?v=K8qVH8V0VvY&t=337s)에서 \nVS Code의 설치와 사용법에 대한 상세한 설명을 들을 수 있다.\n:::\n", "_____no_output_____" ], [ ":::{prf:example}\n:label: my_file\n\n아래 내용을 담은 *my_file.py* 파일을 작성하고 저장하라.\n여기서는 *codes* 라는 하위 디렉터리(폴더)에 저장되어 있다고 가정한다.\n\n```\ns = 'Hello world'\nprint(s)\n```\n\n이제 주피터 노트북의 코드 셀에서 아래 명령문을 실행해보자.\n\n```python\nIn [1]: %run codes/my_file.py\n파이썬 안녕\n```\n\n`%run my_file.py`은 IPython에서 *my_file.py* 파일에 포함된 모든 코드를 실행한다.\n그리고 이제는 코드에서 정의된 변수와 변수가 가리키는 값을 확인할 수 있다.\n\n```python\nIn [2]: s\nOut[2]: 'Hello world'\n```\n\n`%whos`는 선언된 변수에 대한 정보를 보여준다.\n여기서는 변수 `s`는 `'파이썬 안녕'` 이라는 문자열(`str`)을 가리키고 있음을 확인해준다. \n\n```python\nIn [3]: %whos\nVariable Type Data/Info\n----------------------------\ns str 파이썬 안녕\n```\n:::", "_____no_output_____" ], [ ":::{admonition} 매직 커맨드\n:class: info\n\n퍼센트 기호 `%`로 시작하는 명령어는 파이썬 명령어가 아니며,\n파이썬 코드 파일 및 디렉터리 경로 관리 등에 사용하는 IPython 전용 명령어이다.\n**매직 커맨드**<font size=\"2\">magic command</font>라 불리며,\n앞으로 기회될 때마다 하나씩 소개될 것이다.\n매직 커맨드에 자세한 정보는 [IPython 공식 문서](https://ipython.readthedocs.io/en/stable/interactive/magics.html)에서 확인할 수 있다.\n:::", "_____no_output_____" ] ] ]

[ "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "Unlicense" ]

[ "Unlicense" ]

[ "Unlicense" ]

[ [ [ "<img align=\"left\" src=\"./img/lu.png\" hspace=\"20\"/> <img align=\"right\" src=\"./img/midlands+.png\"/>\n<br/><br/><br/><br/><br/><br/><br/>\n\n## Research computing with Python\n\n------\n\n### Workflow of research computing \n* Literature review\n* Ideas\n\t- Hypothesis formulation\n\t- Methodology\n* Data generation\n\t- Simulation - coding by yourself or use existing models (such as [LAMMPS](http://lammps.sandia.gov/doc/Manual.html) and [OpenFOAM](https://openfoam.org/))\n\t- Experiment control \n* Data analysis\n\t- Tools for data post-processing\n\t- Implementation of algorithm\n\t- Visualisation \n* Publishing your results\n\t- Manuscripts\n\t- Figures/tables/animations\n\t- Your research data and source codes might be required by reviewers so that they can reproduce and validate your published results\n\n------\n\n### Requirements in computational-based research\n_\"Just make it work\"_ is NOT enough.\n\n* Minimum standard: __reproducibility__ - both the author and other researchers are able to rerun the simulations and reproduce the same results using the data and computer code that are used to generate the published results by the author\n\n* Ultimate standard: __replicability__ - research findings/claims that invlove numerical simulations are able to be replicated by other researchers using independent methods and data (e.g. can your simulation results be validated against that of experiments?) \n\nTherefore reproducible may _NOT_ be replicible. \n\nSee: [Peng, 2011. Reproducible Research in Computational Science. DOI: 10.1126/science.1213847](http://science.sciencemag.org/content/334/6060/1226.full) \n\n------\n\n### Why Python\nPython is a modern, fully-featured, general-purpose, high-level interpreted language, and supports multiple programming paradigms, e.g. object-oriented and functional programming.\n\n* Easy to learn and quick to program in - more time on scientific thinking, less time on programming. Note that our main work is research.\n* Dynamically-typed and automatic memory management - No need to define types for variables and functions. No need to manually allocate and deallocate memory for data arrays \n* Expressive - not only readable, but also concise ", "_____no_output_____" ] ], [ [ "persons = [name for name in [\"Adam\", \"James\", \"Dan\", \"Smith\"] if name.startswith(\"A\") or name.endswith(\"s\")]\nprint(persons)", "['Adam', 'James']\n" ] ], [ [ "* Very rich collection of numerical libraries, scientifc packages and visualisation functionalities - [Numpy](http://www.numpy.org/), [Scipy](https://www.scipy.org/scipylib/index.html), [SymPy](http://www.sympy.org/en/index.html), [Matplotlib](https://matplotlib.org/), [PyQtGraph](http://www.pyqtgraph.org/) and etc.\n* A variety of development environments\n\t- Interactive: [IPython](https://ipython.org/) and [Jupyter notebooks](https://jupyter.org/). \n\t- IDE: [PyCharm](https://www.jetbrains.com/pycharm/), [Spyder](https://pythonhosted.org/spyder/) and [Eclipse](http://www.eclipse.org/) with [PyDev](http://www.pydev.org/) plugin. Note that PyCharm also supports IPython and Jupyter notebooks.\n* Interfacing with C/C++/Fortran - leave heavy computations with C/C++/Fortran and use Python as \"glue\" or \"wapper\". F2py (included in Numpy) for Fortran and [Cython](http://cython.org/)/[SWIG](http://www.swig.org/) for C/C++\n* Good support for parallel computing - e.g. [Multiprocessing](https://docs.python.org/2/library/multiprocessing.html) for shared memory system, MPI based [MPI4Py](http://mpi4py.readthedocs.io/en/stable/) for distributed memory system and [PyCUDA](https://mathema.tician.de/software/pycuda/) for GPU computing \n* Free, open source and large user community\n\nUseful links:\n>Python documentation official site: [https://www.python.org/doc/](https://www.python.org/doc/)<br/>\n>Python scientific computing ecosystem: [https://www.scipy.org/](https://www.scipy.org/); [http://www.scipy-lectures.org/intro/intro.html](http://www.scipy-lectures.org/intro/intro.html)<br/>\n>Think Python: [http://greenteapress.com/thinkpython/thinkpython.pdf](http://greenteapress.com/thinkpython/thinkpython.pdf)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy as np\nimport pandas as pd\nimport math\nfrom numpy import array, median\nfrom hw import Jamshidian as jamsh\nfrom hw import Henrard as henr\nfrom hw import calibration as hw_calib\nfrom hw.const import *\nfrom fox_toolbox.utils import rates\nfrom fox_toolbox.utils import volatility\nfrom fox_toolbox.utils import xml_parser\n# from fox_toolbox.utils \nfrom tsr import csv_parser, tsr, linear\nfrom random import choice\nimport matplotlib.pyplot as plt\nfrom termcolor import colored\n\nnp.set_printoptions(precision=4)\n\n%load_ext autoreload\n%autoreload 2", "The autoreload extension is already loaded. To reload it, use:\n %reload_ext autoreload\n" ] ], [ [ "### Read IRSM FORM", "_____no_output_____" ] ], [ [ "cms_xml = xml_parser.get_files('irsmform xml', folder = 'linear TSR logs')\ncms_xml_out = xml_parser.get_files('out xml', folder = 'linear TSR logs')\ncms_csv = xml_parser.get_files('CMS 10y csv', folder = 'linear TSR logs')\n\ncms_replic_basket = csv_parser.parse_csv(cms_csv)\ncal_basket = list(xml_parser.get_calib_basket(cms_xml_out))", "Parsing CmsFlow csv log\n" ], [ "main_curve, sprds = xml_parser.get_rate_curves(cms_xml)\ndsc_curve = main_curve\n\ntry:\n estim_curve = sprds[0]\nexcept TypeError:\n estim_curve = main_curve", "_____no_output_____" ] ], [ [ "### Kmin & Kmax reconciliation", "_____no_output_____" ] ], [ [ "maxe = 0\ntsr_fwds, xml_fwds = [], []\nfor (caplet, floorlet, swaplet), swo in zip(cms_replic_basket, cal_basket):\n tsr_fwds.append(caplet.fwd)\n xml_fwds.append(swo.get_swap_rate(dsc_curve, estim_curve))\n \n kmax = tsr.minmax_strikes(swo.vol, swo.expiry, swo.get_swap_rate(dsc_curve, estim_curve), caplet.n).kmax \n kmin = tsr.minmax_strikes(swo.vol, swo.expiry, swo.get_swap_rate(dsc_curve, estim_curve), floorlet.n).kmin\n maxe = max(maxe, kmax - caplet.strike_max)\n# print('Tf', int(caplet.fixing_date),'kmax diff: ',kmax - caplet.strike_max,'kmin diff: ',kmin - floorlet.strike_min)\n \nprint(colored('hello', 'red') if maxe > 1e-09 else colored('OK', 'green'))", "\u001b[32mOK\u001b[0m\n" ], [ "array(xml_fwds) - array(tsr_fwds)", "_____no_output_____" ], [ "print(colored('hello', 'red') if max(array(xml_fwds) - array(tsr_fwds)) > 1e-09 else colored('OK', 'green'))", "\u001b[32mOK\u001b[0m\n" ] ], [ [ "### Strike ladder recon", "_____no_output_____" ] ], [ [ "swo = cal_basket[-1]\ncaplet, floorlet, swaplet = cms_replic_basket[-1]\n\nfwd = swo.get_swap_rate(dsc_curve, estim_curve)\nnref = caplet.n\n\nminmax_strikes = tsr.minmax_strikes(swo.vol, swo.expiry, fwd, nref)\n\nneff_capl = math.ceil((minmax_strikes.kmax - minmax_strikes.fwd)/minmax_strikes.kstep) + 1\nneff_floo = math.floor((minmax_strikes.fwd - minmax_strikes.kmin)/minmax_strikes.kstep) + 1\n\nstrikes_ladders = tsr.build_strike_ladders(minmax_strikes, neff_capl, neff_floo)\n\n# print(caplet.calib_basket.Strike.values - strikes_ladders.caplet_ladder)\nmax(caplet.calib_basket.Strike.values - strikes_ladders.caplet_ladder)\nprint(colored('hello', 'red') if max(caplet.calib_basket.Strike.values - strikes_ladders.caplet_ladder) > 1e-09 else\\\n colored('OK', 'green'))", "\u001b[32mOK\u001b[0m\n" ], [ "# print(floorlet.calib_basket.Strike.values - strikes_ladders.floorlet_ladder)\n\nprint(colored('hello', 'red') if max(floorlet.calib_basket.Strike.values - strikes_ladders.floorlet_ladder) > 1e-09\\\n else colored('OK', 'green'))", "\u001b[32mOK\u001b[0m\n" ] ], [ [ "### Weights recon", "_____no_output_____" ] ], [ [ "mr = xml_parser.get_tsr_params(cms_xml_out).meanRevTSRSwapRate(caplet.fixing_date)\ntsr_coeff = linear.get_coeff(caplet.pmnt_date, dsc_curve, swo, mr, estim_curve)\ntsr_weights = tsr.build_weights(minmax_strikes, neff_capl, neff_floo, tsr_coeff)\n\n# print(caplet.calib_basket.Weights.values - tsr_weights.capletWeights)\n\nprint(colored('ALARM', 'red') if max(abs(caplet.calib_basket.Weights.values - tsr_weights.capletWeights)) > 3e-09\\\n else colored('OK', 'green'))", "\u001b[32mOK\u001b[0m\n" ], [ "# print(floorlet.calib_basket.Weights.values - tsr_weights.floorletWeights)\n\nprint(colored('ALARM', 'red') if max(abs(floorlet.calib_basket.Weights.values - tsr_weights.floorletWeights)) > 3e-09\\\n else colored('OK', 'green'))", "\u001b[32mOK\u001b[0m\n" ] ], [ [ "### Disc(Tf, Tp) / Annuity", "_____no_output_____" ] ], [ [ "print(caplet.calib_basket['Disc/A'].values - tsr.get_DiscOverAnnuity(strikes_ladders.caplet_ladder, tsr_coeff))\n\nprint(colored('ALARM', 'red') if max(abs(caplet.calib_basket['Disc/A'].values -\\\n tsr.get_DiscOverAnnuity(strikes_ladders.caplet_ladder, tsr_coeff))) > 3e-09 else colored('OK', 'green'))", "[2.1060e-09 2.0325e-09 1.9589e-09 1.8852e-09 1.8117e-09 1.7381e-09\n 1.6646e-09 1.5909e-09 1.5174e-09 1.4438e-09 1.3702e-09 1.2966e-09\n 1.2230e-09 1.1495e-09 1.0758e-09 1.0023e-09 9.2870e-10 8.5514e-10\n 7.8148e-10 7.0793e-10 6.3437e-10 5.6071e-10 4.8715e-10 4.1360e-10\n 3.4004e-10]\n\u001b[32mOK\u001b[0m\n" ], [ "# print(floorlet.calib_basket['Disc/A'].values - tsr.get_DiscOverAnnuity(strikes_ladders.floorlet_ladder, tsr_coeff))\n\n\nprint(colored('ALARM', 'red') if max(abs(floorlet.calib_basket['Disc/A'].values - \\\n tsr.get_DiscOverAnnuity(strikes_ladders.floorlet_ladder, tsr_coeff))) > 4e-09 else colored('OK', 'green'))", "\u001b[32mOK\u001b[0m\n" ], [ "myBachelierCaplet = array([volatility.BachelierPrice(F=swo.get_swap_rate(dsc_curve, estim_curve), \n K=strike, \n v=swo.vol.value*np.sqrt(swo.expiry)) \n * swo.get_annuity(dsc_curve) / dsc_curve.get_dsc(swo.start_date)\n for strike in strikes_ladders.caplet_ladder])\n\nplt.plot(myBachelierCaplet, label='Bachelier')\n\nplt.plot(caplet.calib_basket.SwoPrice.values, label='Swaption', ls='--')\nplt.legend()\n\nmax(myBachelierCaplet - caplet.calib_basket.SwoPrice.values)\n\nprint(colored('ALARM', 'red') if max(myBachelierCaplet - caplet.calib_basket.SwoPrice.values) > 2e-05 else colored('OK e-05', 'green'))", "\u001b[32mOK e-05\u001b[0m\n" ], [ "(myBachelierCaplet - caplet.calib_basket.SwoPrice.values)", "_____no_output_____" ], [ "myBachelierFloorlet = array([volatility.BachelierPrice(\n F=swo.get_swap_rate(dsc_curve, estim_curve), \n K=strike, \n v=swo.vol.value*np.sqrt(swo.expiry), w=-1) \n * swo.get_annuity(dsc_curve) / dsc_curve.get_dsc(swo.start_date)\n for strike in strikes_ladders.floorlet_ladder])\n\nplt.plot(myBachelierFloorlet, label='Bachelier')\n\nplt.plot(floorlet.calib_basket.SwoPrice.values, label='Swaption')\nplt.legend()\n\nprint(colored('ALARM', 'red') if max(myBachelierFloorlet - floorlet.calib_basket.SwoPrice.values) > 2e-05 else colored('OK e-05', 'green'))", "\u001b[32mOK e-05\u001b[0m\n" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "### Cyclical figurate numbers\nProblem 61\n\nhttps://projecteuler.net/minimal=61", "_____no_output_____" ], [ "<p>Triangle, square, pentagonal, hexagonal, heptagonal, and octagonal numbers are all figurate (polygonal) numbers and are generated by the following formulae:</p>\n<table><tr><td>Triangle</td>\n<td> </td>\n<td>P_3,<i>n</i>=<i>n</i>(<i>n</i>+1)/2</td>\n<td> </td>\n<td>1, 3, 6, 10, 15, ...</td>\n</tr><tr><td>Square</td>\n<td> </td>\n<td>P_4,<i>n</i>=<i>n</i>²</td>\n<td> </td>\n<td>1, 4, 9, 16, 25, ...</td>\n</tr><tr><td>Pentagonal</td>\n<td> </td>\n<td>P_5,<i>n</i>=<i>n</i>(3<i>n</i>−1)/2</td>\n<td> </td>\n<td>1, 5, 12, 22, 35, ...</td>\n</tr><tr><td>Hexagonal</td>\n<td> </td>\n<td>P_6,<i>n</i>=<i>n</i>(2<i>n</i>−1)</td>\n<td> </td>\n<td>1, 6, 15, 28, 45, ...</td>\n</tr><tr><td>Heptagonal</td>\n<td> </td>\n<td>P_7,<i>n</i>=<i>n</i>(5<i>n</i>−3)/2</td>\n<td> </td>\n<td>1, 7, 18, 34, 55, ...</td>\n</tr><tr><td>Octagonal</td>\n<td> </td>\n<td>P_8,<i>n</i>=<i>n</i>(3<i>n</i>−2)</td>\n<td> </td>\n<td>1, 8, 21, 40, 65, ...</td>\n</tr></table><p>The ordered set of three 4-digit numbers: 8128, 2882, 8281, has three interesting properties.</p>\n<ol><li>The set is cyclic, in that the last two digits of each number is the first two digits of the next number (including the last number with the first).</li>\n<li>Each polygonal type: triangle (P_3,127=8128), square (P_4,91=8281), and pentagonal (P_5,44=2882), is represented by a different number in the set.</li>\n<li>This is the only set of 4-digit numbers with this property.</li>\n</ol><p>Find the sum of the only ordered set of six cyclic 4-digit numbers for which each polygonal type: triangle, square, pentagonal, hexagonal, heptagonal, and octagonal, is represented by a different number in the set.</p>\n", "_____no_output_____" ] ], [ [ "triangle = lambda n: int( (n*(n+1))/2 )\nsquare = lambda n: int( n**2 )\npentagonal = lambda n: int( (n*(3*n-1))/2 )\nhexagonal = lambda n: ( n*(2*n-1) )\nheptagonal = lambda n: int( (n*(5*n-3))/2 )\noctagonal = lambda n: int( n*(3*n-2) )\n\n\n# Tests\nassert [triangle(x) for x in range(1, 6)] == [1,3,6,10,15]\nassert [square(x) for x in range(1, 6)] == [1,4,9,16,25]\nassert [pentagonal(x) for x in range(1, 6)] == [1,5,12,22,35]\nassert [hexagonal(x) for x in range(1, 6)] == [1,6,15,28,45]\nassert [heptagonal(x) for x in range(1, 6)] == [1,7,18,34,55]\nassert [octagonal(x) for x in range(1, 6)] == [1,8,21,40,65]\n\n\ndef get_q_r(x):\n return (x // 100, x % 100)\n\n\ndef generate_polygonal_numbers(func):\n \"\"\"\n Returns list of numbers between 1010 and 9999 given a function.\n \n \"\"\"\n result = []\n \n for n in range(1, 150):\n p = func(n)\n q, r = get_q_r(p)\n if (1010 <= p <= 9999) & (r >= 10):\n result.append(p)\n if p >= 9999:\n break\n\n return result\n\ntriangle_nums = generate_polygonal_numbers(triangle)\nsquare_nums = generate_polygonal_numbers(square)\npentagonal_nums = generate_polygonal_numbers(pentagonal)\nhexagonal_nums = generate_polygonal_numbers(hexagonal)\nheptagonal_nums = generate_polygonal_numbers(heptagonal)\noctagonal_nums = generate_polygonal_numbers(octagonal)\n\npolygonal_sets = [triangle_nums, square_nums, pentagonal_nums, hexagonal_nums, heptagonal_nums, octagonal_nums]\n\n", "_____no_output_____" ], [ "for p3 in triangle_nums:\n for p4 in square_nums:\n for p5 in pentagonal_nums:\n if len(set((p3, p4, p5))) < 3:\n continue\n q3, r3 = get_q_r(p3)\n q4, r4 = get_q_r(p4)\n q5, r5 = get_q_r(p5)\n if (r3 == q4) & (r4 == q5) & (r5 == q3):\n print(p3, p4, p5)\n elif (r3 == q5) & (r5 == q4) & (r4 == q3):\n print(p3, p4, p5)\n", "8128 8281 2882\n" ], [ "1024**0.5", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n%matplotlib inline", "_____no_output_____" ], [ "x=pd.read_csv('https://s3.amazonaws.com/drivendata/data/44/public/dengue_features_train.csv')\ny=pd.read_csv('https://s3.amazonaws.com/drivendata/data/44/public/dengue_labels_train.csv')\nx_test=pd.read_csv('https://s3.amazonaws.com/drivendata/data/44/public/dengue_features_test.csv')\nsubmission_file=pd.read_csv('https://s3.amazonaws.com/drivendata/data/44/public/submission_format.csv')", "_____no_output_____" ], [ "x.fillna(method='ffill', inplace=True)\nx_test.fillna(method='ffill', inplace=True)", "_____no_output_____" ], [ "features=['ndvi_ne','year','weekofyear','ndvi_se','ndvi_nw','reanalysis_air_temp_k','precipitation_amt_mm']\nfe=['year','weekofyear','station_avg_temp_c','reanalysis_dew_point_temp_k','ndvi_ne','reanalysis_tdtr_k']", "_____no_output_____" ], [ "X=x[fe]\nX.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 1456 entries, 0 to 1455\nData columns (total 6 columns):\nyear 1456 non-null int64\nweekofyear 1456 non-null int64\nstation_avg_temp_c 1456 non-null float64\nreanalysis_dew_point_temp_k 1456 non-null float64\nndvi_ne 1456 non-null float64\nreanalysis_tdtr_k 1456 non-null float64\ndtypes: float64(4), int64(2)\nmemory usage: 68.3 KB\n" ], [ "y.drop(columns='city',inplace=True)\ny.drop(columns='year',inplace=True)\ny.drop(columns='weekofyear',inplace=True)", "_____no_output_____" ], [ "from sklearn.model_selection import train_test_split\nseed = 0\ntest_size = 0.2\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=seed)", "_____no_output_____" ], [ "from xgboost import XGBRegressor\nmy_model = XGBRegressor(learning_rate=0.009,n_estimators=1500,subsample=1,max_depth=7,cosample_bytree=1,gamma=1)\nmy_model.fit(X_train, y_train)", "[21:15:20] WARNING: /workspace/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.\n" ], [ "from sklearn.metrics import mean_absolute_error\npredictions = my_model.predict(X_test)\n\nprint(\"Mean Absolute Error: \" + str(mean_absolute_error(predictions, y_test)))", "Mean Absolute Error: 9.662770768142726\n" ], [ "model_full=XGBRegressor(learning_rate=0.009,n_estimators=1500,subsample=1,max_depth=7,cosample_bytree=1,gamma=1)\nmodel_full.fit(X,y)\nx_test=x_test[fe]\nx.head()\nx_test.head()", "[21:15:23] WARNING: /workspace/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.\n" ], [ "#x_test['city1']=np.where(x_test['city']=='sj',1,-1)\n#x_test.drop(columns='city',inplace=True)", "_____no_output_____" ], [ "test_pred=model_full.predict(x_test).astype(int)\nsubmission=pd.read_csv('https://s3.amazonaws.com/drivendata/data/44/public/submission_format.csv',index_col=[0,1,2])\nsubmission.total_cases=test_pred\nsubmission.to_csv('value.csv')", "_____no_output_____" ], [ "from sklearn.ensemble import RandomForestRegressor\nrf=RandomForestRegressor()\nrf.fit(X_train,y_train)\n", "/usr/local/lib/python3.6/dist-packages/sklearn/ensemble/forest.py:245: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:3: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n This is separate from the ipykernel package so we can avoid doing imports until\n" ], [ "from sklearn.metrics import mean_absolute_error\npredictions = rf.predict(X_test)\nprint(\"Mean Absolute Error: \" + str(mean_absolute_error(predictions, y_test)))", "Mean Absolute Error: 10.837328767123287\n" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import requests\nfrom bs4 import BeautifulSoup\nimport pandas as pd", "_____no_output_____" ], [ "data = list()\nfor i in list(range(1, 21)):\n page = i\n url = \"https://hypeauditor.com/top-instagram-all-brazil/?p={}\".format(page)\n texto = requests.get(url).text\n soup = BeautifulSoup(texto, 'lxml')\n _table = soup.find('table',{'class':'kyb-table bloggers-top-table'})\n tbody = _table.find('tbody')\n trs = tbody.findAll('tr')\n # loop\n for tr in trs:\n tds = tr.findAll('td')\n name = tds[2].find('h4').get_text()\n username = tds[2].find('a').get_text()\n topics = [span.get_text() for span in tds[3].findAll('span')]\n topics = str(topics).replace(\"'\", '').replace(\"[\", '').replace(\"]\", '')\n from_brazil = tds[4].get_text().replace(' ', '')\n if 'M' in from_brazil:\n from_brazil = float(from_brazil.replace('M', '')) * 1000000\n elif 'K' in from_brazil:\n from_brazil = float(from_brazil.replace('K', '')) * 1000\n elif 'N/A' in from_brazil:\n from_brazil = 0.0\n else:\n from_brazil = float(from_brazil) \n engagement = tds[6].get_text().replace('\\n', '').replace(' ', '')\n data.append([name, username, topics, from_brazil, engagement])", "_____no_output_____" ], [ "df = pd.DataFrame(data, columns = ['name', 'username', 'topics', 'followers', 'engagement'])\ndf.head()", "_____no_output_____" ], [ "df.shape", "_____no_output_____" ], [ "ordered = df.sort_values('followers', ascending=True)", "_____no_output_____" ], [ "ordered.to_csv('instagram.csv')", "_____no_output_____" ], [ "topics = [value[0] for value in ordered[['topics']].values]\ntopics_set = list()\nfor t in topics:\n if t == '':\n continue\n else:\n ts = t.split(',')\n for item in ts:\n topics_set.append(item)", "_____no_output_____" ], [ "topics_set = set(topics_set)", "_____no_output_____" ], [ "pd.DataFrame(data = list(topics_set), columns=['topics'])", "_____no_output_____" ], [ "ordered[ordered.topics.str.contains('Music')]", "_____no_output_____" ], [ "import os\nos.system('instagram-scraper @kicky -u aurevoirstuffs -p Ea@901facebook')", "_____no_output_____" ], [ "!pwd", "/f/repositories/skhb\n" ], [ "import requests\nimport urllib.request\nimport urllib.parse\nimport urllib.error\nfrom bs4 import BeautifulSoup\nimport ssl\nimport json", "_____no_output_____" ], [ "class Insta_Info_Scraper:\n\n def getinfo(self, url):\n self.ctx = ssl.create_default_context()\n html = urllib.request.urlopen(url, context=self.ctx).read()\n soup = BeautifulSoup(html, 'html.parser')\n data = soup.find_all('meta', attrs={'property': 'og:description'\n })\n text = data[0].get('content').split()\n user = '%s %s %s' % (text[-3], text[-2], text[-1])\n followers = text[0]\n following = text[2]\n posts = text[4]\n print ('User:', user)\n print ('Followers:', followers)\n print ('Following:', following)\n print ('Posts:', posts)\n print ('---------------------------')", "_____no_output_____" ], [ "obj = Insta_Info_Scraper()\nobj.getinfo('https://www.instagram.com/maisa/')", "User: from +A (@maisa)\nFollowers: 23.3m\nFollowing: 2,869\nPosts: 2,061\n---------------------------\n" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]