path
stringlengths
7
265
concatenated_notebook
stringlengths
46
17M
Notebooks/ComputerVision/7. CV. Hough Lines.ipynb
###Markdown Hough transform Line detectionThe simplest boundary you can detect is a line and more complex boundaries are often made up of several lines. When you do edge detection you'll find that edges when pieced together form longer line segments and shapes. We can think of representing any line as a function of space. In image space the equation that represents a line is $y=m x + b$ where $m$ is the slope of the line and $b$ is how far it shifted up or down.A useful transformation is moving this line representation from image space to Hough space, also called parameter space. The Hough transform converts data points from image space to Hough space and represents a line in the simplest way: as a point at the coordinate $m_0$, $b_0$ which are the same $m$ and $b$ from the line equation $y=m x + b$. ![Hough transform](images/hough_transform.png) Patterns in Hough space can help us identify lines or other shapes. For example, look at these two lines in Hough space that intersect at the point m_b_0. In image space, it's the line with the equation $y = m_0 x + b_0.$ ![Hough transform, image space](images/hough_transform_2.png) And if we have a line made of mini segments or points close to the same line equation in image space this turns into many intersecting lines in Hough space. Imagine this line as part of an edge detected image where a line just has some small discontinuities in it. Our strategy then for finding continuous lines in an image is to look at intersection points in Hough space. ![Hough transform, continuous line](images/hough_transform_3.png) Straight up and down lines have an infinite slopes. A better way to transform image space is by turning Hough space into polar coordinates. Instead of $m$ and $b$, $rho$, which is the distance of the line from the origin and $\theta$ which is the angle from the horizontal axis are used. A fragmented line or points that fall in a line can be identified in Hough space as the intersection of sinusoids. ![Hough transform, sinusoidal intersection](images/hough_transform_4.png) Hough Lines detection ###Code import numpy as np import cv2 import matplotlib.pyplot as plt %matplotlib inline # read and display de image image = cv2.imread('images/phone.jpg') image_copy = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.imshow(image_copy) # convert to gray scale and perform edge detection image_gray = cv2.cvtColor(image_copy, cv2.COLOR_RGB2GRAY) # Canny parmeters low = 50 high = 100 image_edges = cv2.Canny(image_gray, low, high) plt.imshow(image_edges, cmap="gray") # define the Hough transform parameters # make a blank the same size as our image to draw on rho = 3 theta = np.pi/270 threshold = 10 min_line_length = 100 max_line_gap = 5 line_image = np.copy(image_copy) # run Hough on the edge-detected image lines = cv2.HoughLinesP(image_edges, rho, theta, threshold, np.array([]), min_line_length, max_line_gap) # iterate over the output "lines" and draw lines on the image copy for line in lines: for x1,y1,x2,y2 in line: cv2.line(line_image,(x1,y1),(x2,y2),(255,0,0),12) plt.imshow(line_image) ###Output _____no_output_____
时间序列分析/金融时间序列入门.ipynb
###Markdown **一、与时间序列分析相关的部分基础知识/概念** 1.1 什么是时间序列简而言之:对某一个或者一组变量$x\left ( t \right )$进行观察测量,将在一系列时刻$t_{1},t_{2},⋯,t_{n}$所得到的离散数字组成的序列集合,称之为时间序列。例如: 某股票A从2015年6月1日到2016年6月1日之间各个交易日的收盘价,可以构成一个时间序列;某地每天的最高气温可以构成一个时间序列。一些特征: **趋势**:是时间序列在长时期内呈现出来的持续向上或持续向下的变动。**季节变动**:是时间序列在一年内重复出现的周期性波动。它是诸如气候条件、生产条件、节假日或人们的风俗习惯等各种因素影响的结果。**周期波动**:是时间序列呈现出得非固定长度的周期性变动。循环波动的周期可能会持续一段时间,但与趋势不同,它不是朝着单一方向的持续变动,而是涨落相同的交替波动。**随机波动**:是时间序列中除去趋势、季节变动和周期波动之后的随机波动。不规则波动通常总是夹杂在时间序列中,致使时间序列产生一种波浪形或震荡式的变动。只含有随机波动的序列也称为**平稳序列**。 ###Code 1.白噪声序列:无任何规则,预测没有意义 2.平稳非白噪声序列:均值和方差都是常数 3.非平稳序列:转化为平稳序列,然后按照平稳序列的算法拟合 差分变换--->ARIMA 1.单变量时间序列 ARMA--->GARCH 2.多变量时间序列 VAR----->MGARCH ###Output _____no_output_____ ###Markdown 待分析的时间序列 ---> 平稳性检验 非 转换为平稳序列 差分 * 单位根检验 * ACF PACF * 截尾 * 拖尾 ---> 白噪声检验 * 是白噪声 停止 * 不是白噪声 计算ACF PACF ---> 模型识别 ---> 参数估计 ---> 模型检验 ---> 模型优化 ---> 模型预测 1.2 平稳性平稳时间序列粗略地讲,一个时间序列,如果均值没有系统的变化(无趋势)、方差没有系统变化,且严格消除了周期性变化,就称之是平稳的。 ###Code IndexData = DataAPI.MktIdxdGet(indexID=u"",ticker=u"000001",beginDate=u"20130101",endDate=u"20140801",field=u"tradeDate,closeIndex,CHGPct",pandas="1") IndexData = IndexData.set_index(IndexData['tradeDate']) IndexData['colseIndexDiff_1'] = IndexData['closeIndex'].diff(1) # 1阶差分处理 IndexData['closeIndexDiff_2'] = IndexData['colseIndexDiff_1'].diff(1) # 2阶差分处理 IndexData.plot(subplots=True,figsize=(18,12)) ###Output _____no_output_____ ###Markdown ![image.png](attachment:c5a35196-32fd-4b18-8e5d-bc29295a8d54.png) 上图中第一张图为上证综指部分年份的收盘指数,是一个**非平稳时间序列**;而下面两张为**平稳时间序列**(当然这里没有检验,只是为了让大家看出差异,关于检验序列的平稳性后续会讨论) 细心的朋友已经发现,下面两张图,实际上是对第一个序列做了**差分**处理,方差和均值基本平稳,成为了平稳时间序列,后面我们会谈到这种处理。下面可以给出平稳性的定义了: **严平稳**:如果对所有的时刻t,任意正整数k和任意k个正整数$(t_{1},t_{2},...,t_{k})$, $(r_{t_{1}},r_{t_{2}},...,r_{t_{k}})$ 的联合分布与 $(r_{t_{1}+t},r_{t_{2}+t},...,r_{t_{k}+t})$ 的联合分布相同,我们称时间序列{rt}是**严平稳**的。也就是, $(r_{t_{1}},r_{t_{2}},...,r_{t_{k}})$ 的联合分布在时间的平移变换下保持不变,这是个很强的条件。而我们经常假定的是平稳性的一个较弱的方式 ![image.png](attachment:22f25d4e-fb55-45f2-bf40-ccc7aecc39c0.png) 1.3 相关系数和自相关函数 1.3.1 相关系数 ![image.png](attachment:aacc2a56-01ef-42b9-beb2-5f8f18da11f3.png) ###Code import numpy as np import pandas as pd import matplotlib.pyplot as plt a = pd.Series([9,8,7,5,4,2]) b = a - a.mean() # 去均值 plt.figure(figsize=(10,4)) a.plot(label='a') b.plot(label='mean removed a') plt.legend() ###Output _____no_output_____ ###Markdown 1.3.2 自相关函数 (Autocorrelation Function, ACF) ![image.png](attachment:8fcb2fb7-6f35-49d7-b330-b96134ebb938.png) ![image.png](attachment:c74141f5-8fd3-43d8-8b0a-a835696884f9.png) 下面给出示例: ###Code from scipy import stats import statsmodels.api as sm # 统计相关的库 data = IndexData['closeIndex'] # 上证指数 m = 10 # 我们检验10个自相关系数 acf,q,p = sm.tsa.acf(data,nlags=m,qstat=True) ## 计算自相关系数 及p-value out = np.c_[range(1,11), acf[1:], q, p] output=pd.DataFrame(out, columns=['lag', "AC", "Q", "P-value"]) output = output.set_index('lag') output ###Output _____no_output_____
S3_Failover_w_SDK.ipynb
###Markdown Python with BOTO3 and OneFS Platform API for S3 Failover **Assumptions:**1. S3 is configured and enabled on both clusters2. buckets are configured on both clusters3. users are equally created on both clusters4. S3 Users are configured with the following RBAC Permission ISI_PRIV_LOGIN_PAPI and (ptional) ISI_PRIV_NS_IFS_ACCESS5. each user has already S3 Keys generated on both clusters If not the Function newS3Key() below can be used to generate them.6. S3 Buckets are equally set up on both clusters Setup and Requirements ###Code # Requirements import boto3 import urllib3 from pprint import pprint # isi_sdk from __future__ import print_function import time import isi_sdk_9_1_0 from isi_sdk_9_1_0.rest import ApiException # Disable SSL selfsigned certificate warnings urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # Config Variables OneFS myHost = '192.168.188.192' # source cluster #myHost = '192.168.188.201' # target cluster myEndpointURL = 'https://' + myHost + ':9021' OneFSUser = 'root' OneFSPw = 'a' ###Output _____no_output_____ ###Markdown Get the S3 Keys using the OneFS SDK ###Code def myS3keys(user, password, papiHost): # Configure HTTP configuration = isi_sdk_9_1_0.Configuration() configuration.username = user configuration.password = password configuration.verify_ssl = False configuration.host = "https://" + papiHost + ":8080" # create an instance of the API class api_instance = isi_sdk_9_1_0.ProtocolsApi(isi_sdk_9_1_0.ApiClient(configuration)) try: api_response = api_instance.list_s3_mykeys() except ApiException as e: print("Exception when calling ProtocolsApi->list_s3_mykeys: %s\n" % e) else : return api_response my = myS3keys(OneFSUser, OneFSPw, myHost) pprint(my) myAccessID = my.keys.access_id mySecretKey = my.keys.secret_key ###Output {'keys': {'access_id': '1_root_accid', 'old_key_expiry': 1636711391, 'old_key_timestamp': 1636704440, 'old_secret_key': 'LcbUd7sU_J2BmD47giMrvACipsZj', 'secret_key': 'GzkYEoCnKn82Jn8pI2EFcQNAuNkf', 'secret_key_timestamp': 1636710791}} ###Markdown Generate a new S3 Key using the OneFS SDK ###Code def newS3key(user, password, papiHost): # Configure HTTP configuration = isi_sdk_9_1_0.Configuration() configuration.username = user configuration.password = password configuration.verify_ssl = False configuration.host = "https://" + papiHost + ":8080" # create an instance of the API class api_instance = isi_sdk_9_1_0.ProtocolsApi(isi_sdk_9_1_0.ApiClient(configuration)) s3_mykey = isi_sdk_9_1_0.S3Key() # S3Key | force = True # bool | Forces to create new key. (optional) try: api_response = api_instance.create_s3_mykey(s3_mykey, force=force) except ApiException as e: print("Exception when calling ProtocolsApi->create_s3_mykey: %s\n" % e) else : return api_response my = newS3key(OneFSUser, OneFSPw, myHost) pprint(my) myAccessID = my.keys.access_id mySecretKey = my.keys.secret_key ###Output {'keys': {'access_id': '1_root_accid', 'old_key_expiry': 1636711391, 'old_key_timestamp': 1636704440, 'old_secret_key': 'LcbUd7sU_J2BmD47giMrvACipsZj', 'secret_key': 'GzkYEoCnKn82Jn8pI2EFcQNAuNkf', 'secret_key_timestamp': 1636710791}} ###Markdown List objects with BOTO - lookup a new Key Pair in case of a authentication error...**Note: There are other reasons why an S3 call could return a 403 Error. => This is for demonstraion purpose only!** It can be potentially dangerous to automatially get the keys and just retry with out further sanity checks. ###Code def listObjects(myAccID, mySecret, myURL, bucket): global myAccessID global mySecretKey # S3 Config # disable unsigned SSL warning urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) from botocore import config from botocore.exceptions import ClientError my_config = config.Config( region_name = "", signature_version = 'v4', retries = { 'max_attempts' : 10, 'mode' : 'standard' } ) # create a S3 Session Object session = boto3.session.Session() s3_client = session.client( service_name='s3', aws_access_key_id=myAccID, aws_secret_access_key=mySecret, endpoint_url=myURL, use_ssl=True, verify=False ) try: pprint(s3_client.list_objects(Bucket=bucket)) except ClientError as e: eStatus = e.response['ResponseMetadata']['HTTPStatusCode'] print(e.response['Error']['Message']) if eStatus == 403 : print("Time to add the call to get a new key") my = myS3keys(OneFSUser, OneFSPw, myHost) pprint(my) myAccessID = my.keys.access_id mySecretKey = my.keys.secret_key listObjects(myAccessID, mySecretKey, myURL, bucket) listObjects(myAccessID, mySecretKey, myEndpointURL, 'omnibot') ###Output {'Contents': [{'ETag': '"d41d8cd98f00b204e9800998ecf8427e"', 'Key': 'this_is_cluster_1', 'LastModified': datetime.datetime(2021, 11, 12, 8, 52, 17, tzinfo=tzutc()), 'Owner': {'DisplayName': 'root', 'ID': 'root'}, 'Size': 0, 'StorageClass': 'STANDARD'}], 'IsTruncated': False, 'Marker': '', 'MaxKeys': 1000, 'Name': 'omnibot', 'Prefix': '', 'ResponseMetadata': {'HTTPHeaders': {'connection': 'keep-alive', 'content-length': '460', 'x-amz-request-id': '564950518'}, 'HTTPStatusCode': 200, 'HostId': '', 'RequestId': '564950518', 'RetryAttempts': 0}}
src/main/scala/paristech/.ipynb_checkpoints/TP3_scala-checkpoint.ipynb
###Markdown Supplément test de l' algorithme Decision Tree ###Code val dt = new DecisionTreeClassifier() .setFeaturesCol("features") .setLabelCol("final_status") .setPredictionCol("predictions") .setRawPredictionCol("raw_predictions") val pipeline_dt = new Pipeline() .setStages(Array(tokenizer, remover, cvModel, idf, indexerCountry, indexerCurrency, encoder, assembler, dt)) val bc_model = pipeline_dt.fit(training) val dfWithSimplePredictionsDt = bc_model.transform(test) // Select (prediction, true label) and compute test error. val evaluator_dt = new MulticlassClassificationEvaluator() .setLabelCol("final_status") .setPredictionCol("predictions") .setMetricName("accuracy") val accuracy_dt = evaluator_dt.evaluate(dfWithSimplePredictionsDt) println("Test Error = " + (1.0 - accuracy_dt)) val dtparamGrid = new ParamGridBuilder() .addGrid(dt.maxDepth,(1 to 11 by 1).toArray) .addGrid(dt.maxBins, Array(2,10,20,40,60,80,100)) .build() val dt_tvs = new TrainValidationSplit() .setEstimator(pipeline_dt) .setEvaluator(evaluator_dt) .setEstimatorParamMaps(dtparamGrid) .setTrainRatio(0.7) val model_dt_tvs = dt_tvs.fit(training) val dfWithPredictionsDt = model_dt_tvs.transform(test) //dfWithPredictionsDt.groupBy("final_status", "predictions").count.show() val accuracy_dt_tvs = evaluator_dt.evaluate(dfWithPredictionsDt) println("Test Error = " + (1.0 - accuracy_dt_tvs)) bc_model.write.overwrite.save("models/decision_tree_model") model_tvs.write.overwrite.save("models/model_lr_tvs") ###Output _____no_output_____
notebooks/IPython extension.ipynb
###Markdown While `nb-mermaid` will work with any Jupyter kernel, IPython provides a way to capture loading an extension directly in a cell as a `%linemagic`: ###Code %reload_ext mermaid ###Output _____no_output_____
aps/satskred/import_skreddb/create_test_data2.ipynb
###Markdown The following columns are used in the import routine- time -> skredTidspunkt (should probably be t_1)- time -> registrertDato (should probably be t_1)- geometry -> SHAPE- dem_min -> hoydeStoppSkred_moh- asp_median -> eksposisjonUtlopsomr - slp_mean -> snittHelningUtlopsomr_gr - slp_max -> maksHelningUtlopsomr_gr - slp_min -> minHelningUtlopsomr_gr- area -> arealUtlopsomr_m2 Important: skredID needs to be the same in all tables. ###Code import_list = ['time', 'area', 'dem_min', 'asp_median', 'slp_mean', 'slp_max', 'slp_min', 'geometry'] # Add a name to the polygon gdf['_name'] = "Original" # convert t_0 (the time the reference image was taken) into a datetime object and give it a descriptive name gdf['_reference_date'] = pd.to_datetime(gdf['t_0']) # this actually overwrites the existing column "refdate", but since it is a duplicate of t_0 we don't care. # convert t_1 (the time the activity image was taken) into a datetime object and give it a descriptive name gdf['_detection_date'] = pd.to_datetime(gdf['t_1']) aval_map = gdf.plot(column="area", linewidth=0.3, edgecolor='black', cmap="OrRd", alpha=0.9) plg = gdf['geometry'][0] print(type(plg), plg) print(dt_base.strftime(dt_fmt)) dt_1 = dt_base + timedelta(days=-6, minutes=-1) print(dt_1.strftime(dt_fmt)) print(filename_base.format(dt_base.strftime(dt_fmt_act), dt_1.strftime(dt_fmt_ref))) scns = [] scn_dict = { "scn_0": { "le": 0.005, "re": 0.002, "bn": 0.005, "tn": 0.002, "dem_min": 800, "asp_median": 180, "slp_mean": 9.0, "slp_max": 12.0, "slp_min": 4.0, "days": 1, "seconds": 15, "_dis_id": 1 }, "scn_1": { "le": 0.006, "re": 0.002, "bn": 0.004, "tn": 0.002, "dem_min": 850, "asp_median": 190, "slp_mean": 8.0, "slp_max": 11.0, "slp_min": 3.0, "days": 3, "seconds": 65, "_dis_id": 1 }, "scn_2": { "le": 0.0055, "re": 0.002, "bn": 0.0055, "tn": 0.002, "dem_min": 850, "asp_median": 210, "slp_mean": 7.0, "slp_max": 10.0, "slp_min": 2.0, "days": 8, "seconds": 22, "_dis_id": 1 }, "scn_3": { "le": 0.007, "re": 0.003, "bn": 0.008, "tn": 0.003, "dem_min": 650, "asp_median": 110, "slp_mean": 9.5, "slp_max": 15.0, "slp_min": 5.2, "days": 5, "seconds": 8, "_dis_id": 1 }, "scn_4": { "le": 0.006, "re": 0.002, "bn": 0.006, "tn": 0.005, "dem_min": 770, "asp_median": 140, "slp_mean": 8.5, "slp_max": 14.3, "slp_min": 4.2, "days": 4, "seconds": 78, "_dis_id": 1 } } def create_scenario(sd): # Input is an element from scn_dict # Define the base coordinates for the test polygons e_base = 20.94 n_base= 69.71 dt_fmt = '%Y-%m-%dT%H:%M:%S.%f' dt_fmt_act = '%Y%m%d_%H%M%S' dt_fmt_ref = '%Y%m%d' dt_base = datetime.strptime('2019-08-21T15:51:09.025897', dt_fmt) filename_base ="AvalDet_{0}_ref_{1}_trno_087_ZZ" le = e_base + sd["le"] # left_easting re = le + sd["re"] # right_easting bn = n_base + sd["bn"] # bottom_northing tn = bn + sd["tn"] # top_northing p = Polygon([(le, bn), (re, bn), (re, tn), (le, tn)]) act_date = dt_base + timedelta(days=sd["days"], seconds=sd["seconds"]) ref_date = act_date + timedelta(days=-6, seconds=-60) # Create a copy of the original polygon and alter its properties scn = gdf.copy(deep=True) scn['geometry'] = p print(scn.crs) scn.to_crs({'init': 'epsg:32633'}, inplace=True) print(scn.crs) scn['area'] = scn['geometry'].area scn['length'] = scn['geometry'].length scn.to_crs(gdf.crs, inplace=True) scn['_name'] = filename_base.format(act_date.strftime(dt_fmt_act), ref_date.strftime(dt_fmt_ref)) print(scn['_name'][0]) scn['east'] = scn['geometry'].centroid.x scn['north'] = scn['geometry'].centroid.y scn['dem_min'] = sd['dem_min'] scn['asp_median'] = sd['asp_median'] scn['slp_mean'] = sd['slp_mean'] scn['slp_max'] = sd['slp_max'] scn['slp_min'] = sd['slp_min'] scn['time'] = act_date.strftime(dt_fmt) scn['t_1'] = act_date.strftime(dt_fmt) scn['refdate'] = ref_date.strftime(dt_fmt) scn['t_0'] = ref_date.strftime(dt_fmt) scn['_dis_id'] = 1 # used only to merge (dissolve) polygons for verification needs to be same for all scns new_dir = '../data/{0}'.format(scn['_name'][0]) if not os.path.exists(new_dir): os.mkdir(new_dir) scn.drop(['_detection_date', '_reference_date', '_dis_id'], axis=1).to_file(filename='../data/{0}/{0}.shp'.format(scn['_name'][0], scn['_name'][0])) return scn for sd in scn_dict.keys(): scns.append(create_scenario(scn_dict[sd])) ax = gdf.plot() for scn in scns: scn.plot(ax=ax, edgecolor='black', alpha=0.6) test_scns = pd.concat(scns) new_dir = '../data/scns' if not os.path.exists(new_dir): os.mkdir(new_dir) test_scns.drop(['_detection_date', '_reference_date', '_dis_id'], axis=1).to_file(filename='../data/scns/test_scns.shp') dissolved_scns = test_scns.dissolve(by='_dis_id') test_scns.to_csv('../data/scns/scns.csv') test_scns.filter(import_list).head() ###Output _____no_output_____
2016/Visualization.ipynb
###Markdown Bar Charts ###Code data = np.random.permutation(np.array(["dog"]*10 + ["cat"]*7 + ["rabbit"]*3)) counts = collections.Counter(data) plt.bar(range(len(counts)), counts.values()) plt.xticks(np.arange(len(counts))+0.4, counts.keys()); plt.ylabel("Count") plt.xlabel("Animal"); plt.savefig("barchart.pdf") ###Output _____no_output_____ ###Markdown Pie Charts ###Code plt.pie(counts.values(), labels=counts.keys(), autopct='%1.1f%%', colors=["yellowgreen", "lightskyblue", "gold"]) plt.axis('equal'); plt.savefig("piechart.pdf") ###Output _____no_output_____ ###Markdown Histograms ###Code data = np.random.randn(10000) plt.hist(data, bins=50); plt.xlabel("Value") plt.ylabel("Count") plt.savefig("histogram.pdf") ###Output _____no_output_____ ###Markdown Scatter plot ###Code x = np.random.randn(1000) y = 0.4*x**2 + x + 0.7*np.random.randn(1000) plt.plot(x,y,'.') plt.xlabel("Value 1") plt.ylabel("Value 2") plt.savefig("scatter.pdf") ###Output _____no_output_____ ###Markdown Line plot ###Code x = np.linspace(0,10,1000) y = np.cumsum(0.01*np.random.randn(1000)) plt.plot(x,y,'-') plt.xlabel("Time") plt.ylabel("Value") plt.savefig("line.pdf") ###Output _____no_output_____ ###Markdown Box and whisker plot ###Code category = np.random.choice(['dog','cat','rabbit'], 2000, p=[0.5,0.3,0.2]) weights = np.zeros_like(category, dtype=np.float64) weights[category=="dog"] = 30 + 5*np.random.randn(np.sum(category=="dog")) weights[category=="cat"] = 18 + 3*np.random.randn(np.sum(category=="cat")) weights[category=="rabbit"] = 16 + 4*np.random.randn(np.sum(category=="rabbit")) labels = collections.Counter(category).keys() data = [weights[category==l] for l in labels] # seaborn doesn't capture the plt.boxplot command seaborn.boxplot(data, whis=[1,99], showfliers=True); plt.xticks(np.arange(len(labels))+1, labels); plt.ylabel("Weight") plt.xlabel("Animal") plt.savefig("boxplot.pdf") ###Output _____no_output_____ ###Markdown Heatmap (2D histogram version) ###Code x = np.random.randn(100000) y = 0.4*x**2 + x + 0.7*np.random.randn(100000) plt.hist2d(x, y, bins=100); plt.set_cmap(plt.cm.get_cmap('hot')) plt.grid(False) plt.ylim([-3,8]) plt.xlabel("Value 1") plt.ylabel("Value 2") plt.savefig("hist2d.pdf") ###Output _____no_output_____ ###Markdown Heatmap (matrix version) ###Code category2 = np.zeros_like(category) category2[category=="dog"] = np.random.choice(['dog','cat','rabbit'], np.sum(category=="dog"), p=[0.8,0.05,0.15]) category2[category=="cat"] = np.random.choice(['dog','cat','rabbit'], np.sum(category=="cat"), p=[0.2,0.6,0.2]) category2[category=="rabbit"] = np.random.choice(['dog','cat','rabbit'], np.sum(category=="rabbit"), p=[0.4,0.4,0.2]) counter = collections.Counter(zip(category, category2)) labels = collections.Counter(category).keys() M = np.array([[float(counter[(i,j)]) for i in labels] for j in labels]) M = M / np.sum(M,axis=1)[:,None] plt.imshow(M, interpolation="Nearest", cmap="hot", vmax=1, vmin=0) plt.grid(False) plt.xticks(np.arange(len(labels)), labels); plt.yticks(np.arange(len(labels)), labels); plt.xlabel("Second Pet") plt.ylabel("First Pet") plt.axes().xaxis.tick_top() plt.axes().xaxis.set_label_position("top") plt.savefig("heatmap.pdf") ###Output _____no_output_____ ###Markdown Scatter Matrix ###Code x = np.random.randn(1000) y = 0.4*x**2 + x + 0.7*np.random.randn(1000) z = 0.5 + 0.2*(y-1)**2 + 0.1*np.random.randn(1000) df = pd.DataFrame(np.array([x,y,z]).T) seaborn.pairplot(df); plt.savefig("scatter_matrix.pdf") ###Output _____no_output_____ ###Markdown Bubble chart ###Code plt.scatter(x, y, s=z*20, color=seaborn.color_palette()[0]) plt.xlabel("Value 1") plt.ylabel("Value 2") plt.savefig("bubble.pdf") ###Output _____no_output_____ ###Markdown Color scatter plot ###Code xy1 = np.random.randn(1000,2).dot(np.random.randn(2,2)) + np.random.randn(2) xy2 = np.random.randn(1000,2).dot(np.random.randn(2,2)) + np.random.randn(2) plt.scatter(xy1[:,0], xy1[:,1], color=seaborn.color_palette()[0]) plt.axes().scatter(xy2[:,0], xy2[:,1], color=seaborn.color_palette()[1]) plt.xlabel("Value 1") plt.ylabel("Value 2") plt.legend(["Class 1", "Class 2"]) plt.savefig("scatter_color.pdf") %matplotlib notebook from mpl_toolkits.mplot3d import Axes3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.plot3D(x,y,z, '.') ax.set_xlabel("Value 1") ax.set_ylabel("Value 2") ax.set_zlabel("Value 3"); ###Output _____no_output_____
src/.ipynb_checkpoints/pd-classification-checkpoint.ipynb
###Markdown Parkinson's Disease Classification with KNN by Group 28 (Michael DeMarco, Philip Zhang, Chris Cai, Yuichi Ito) Figure 1 A screengrab from Praat, the acoustic analysis software used in collecting the data set AbstractThis project aims to classify whether or not a given patient has Parkinson's disease based on various variables derived from their speech sounds. We used a KNN classification algorithm with six predictors to create a model with an accuracy of 80%. We concluded it's accuracy is satisfactory for the scope of DSCI 100, working with the tools we had, but not accurate enough for commercial use. We discussed how this study may be extended to other degenerative diseases. Finally, we elaborated on how one would make such a model usable by the public by providing a website frontend for collecting new data points to test. Table of Contents- Introduction - Background - Question - Data set- Methods - Data wrangling and pre-processing - Conducting the Classification Analysis - Predictors - Visualizing the Results- Exploration - Preliminary exploratory data analysis in R - Reading in the data - Wrangling - Creating the training and testing sets - Training set in detail - Predictors in detail- Hypothesis - Expected Outcomes- Results - Classification & Visualization- Discussion - Summary - Impact - Next Steps- References - Works Cited 1 Introduction BackgroundParkinson’s disease (PD) is a degenerative disorder of the central nervous system (CNS) which severely impacts motor control. Parkinson’s has neither a cure nor a known cause. Speech, however, is widely known to play a significant role in the detection of PD. According to Sakar1 , vocal disorder exists in 90% of patients at an early stage.[1] Here's the link to the original [data set](http://archive.ics.uci.edu/ml/datasets/Parkinson%27s+Disease+Classification), and corresponding [paper](https://www.sciencedirect.com/science/article/abs/pii/S1568494618305799?via%3Dihub). Note that the paper used the data set with a similar goal but with very different predictor variables than the ones we select here. QuestionTo what extent can we use elements of speech sounds to predict whether or not a patient has Parkinson’s disease? Data setOur data set is from [UCI’s Machine Learning repository](http://archive.ics.uci.edu/ml/datasets/Parkinson%27s+Disease+Classification). This data set contains numerous variables derived from speech sounds gathered by Sakar using the [Praat](http://www.fon.hum.uva.nl/praat/) acoustic analysis software. Each participant in the study was asked to repeat their pronunciations of the /a/ phoneme three times; each entry is thus associated with an ID parameter ranging from 0 to 251. We chose to focus on the following six predictor parameters:| Speech Sound Component | Variable Name in Data Set | Description ||------------------------------------------|---------------------------|------------------------------------------------------------------|| Pitch Period Entropy (PPE)⁠ | PPE | measures the impaired control of someone’s pitch || Detrended Fluctuation Analysis (DFA)⁠ | DFA | a measure of the ‘noisiness’ of speech waves || Recurrence Period Density Entropy (RPDE)⁠ | RPDE | repetitiveness of speech waves || Jitter | locPctJitter | a measure of frequency instability || Shimmer | locShimmer | a measure of amplitude instability || Fundamental Frequency | meanPeriodPulses | someone’s pitch (calculated from the inverse of the mean period)⁠ |Figure 2 Table describing each of the predictor's used in the original analysisThere’s a lot of complicated mathematics associated with each of these parameters (including Fourier transforms, dense equations, etc.) so the interested reader is encouraged to reference Sakar directly. 2 Methods PredictorsMany researchers have attempted to use speech signal processing for Parkinson’s disease classification. Based on Sakar and other widely supported literature, the predictors identified above are the most popular speech features used in PD studies and should prove effective. They are also all related to motor control, which is what the early stages of Parkinson’s directly impacts. Data wrangling and pre-processingEach participant’s data (i.e., their pronunciation of /a/) was collected three times; to analyze this data set, each of these three observations was merged by taking the mean of each of our predictor variables in question.The data was not completely tidy, but the columns that we used were, so the untidy columns were neglected. Next, to be able to conduct classification, our predictor variables were standardized and centered. Each of our variables had a unique distribution; PPE, DFA, and RPDE were on a scale of 0 to 1 and the pitch variable was on an order of magnitude to 10-3, for example, so the entire data set was scaled so that we did not have to worry about each variable’s individual distribution. Conducting the Classification AnalysisSince our question is a binary classification problem, we used the K-nearest neighbours classification algorithm (KNN). We optimized our choice of k using cross-validation on our training set, and then used the optimal choice of k to create our final model. We then determined its accuracy using the test set. Visualizing the ResultsTo visualize the effectiveness of our KNN model, we were not able to draw a scatter plot directly, as we worked with more than 2-dimensions. We had a line plot showing the trend of increasing values of k on the accuracy of our model for many folds to assist in determining which k we should use for our final model. Then, we created a bar plot to show the number of correct predictions, false positives, and false negatives. Figure 3 An example knn visualization with only two predictors. 3 Exploration Exploratory data analysisWe conducted a preliminary exploration of the data, to getter a better sense of what we were working with. ###Code # Reinstall packages (if needed) # install.packages("tidyverse") # install.packages("caret") # install.packages("repr") # install.packages("GGally") install.packages("formula.tools") # Fix for strange error message # install.packages("e1071") # Load in the necessary libraries library(caret) library(repr) library(GGally) library(tidyverse) library(formula.tools) # Make all of the following results reproducible, use this value across the analysis set.seed(28) ###Output _____no_output_____ ###Markdown Reading in the dataTo begin, we read in the data from the UCI repository. We did not read it directly from UCI's URL, as it contained a zip, and trying to deal with that in R is tedious. Rather, we uploaded the file to Google Drive and we accessed it from there. ###Code # Reads the dataset from the web into R; the Drive URL is self-made pd_data <- read_csv("https://drive.google.com/uc?export=download&id=1p9JuoTRM_-t56x7gptZU2TRNue8IHFHc", skip = 1) #narrows down the dataset to the variables that we will use baseline_data <- pd_data %>% select(id:meanHarmToNoiseHarmonicity, class) head(baseline_data) ###Output _____no_output_____ ###Markdown Figure 4 A slice of the basline data loaded from the UCI repository WranglingAs was mentioned in the methods section, each participant was represented three times (e.g., see three rows with `id == 0` above). We merged these by taking the mean of each of the predictor columns, after grouping by `id`. ###Code # Averages the values of each subject's three trials so that each subject is represented by one row project_data <- baseline_data %>% group_by(id) %>% summarize(PPE = mean(PPE), DFA = mean(DFA), RPDE = mean(RPDE), meanPeriodPulses = mean(meanPeriodPulses), locPctJitter = mean(locPctJitter), locShimmer = mean(locShimmer), # meanAutoCorrHarmonicity = mean(meanAutoCorrHarmonicity),--legacy from project proposal class = mean(class)) %>% mutate(class = as.factor(class)) %>% mutate(has_pd = (class == 1)) head(project_data) ###Output _____no_output_____ ###Markdown Figure 5 A table containing the tidied data and only relevant columns remaining Creating the training and testing setsBelow we created the training and test sets using `createDataPartition()` from the `caret` package. ###Code # Determines which percentage of rows will be used in the training set and testing set (75%/25% split) set.seed(28) training_rows <- project_data %>% select(has_pd) %>% unlist() %>% createDataPartition(p = 0.75, list = FALSE) # Splits the dataset into a training set and testing set training_set <- project_data %>% slice(training_rows) testing_set <- project_data %>% slice(-training_rows) head(training_set) ###Output _____no_output_____ ###Markdown Figure 6 A slice of our training set data, after splitting our data into two separate sets As mentioned in the data wrangling section of "Methods," we eventually scaled our data. Scaling and other pre-processing was done in the analysis section. Testing set in detailHere we looked at the testing set in more detail, exploring the balance and spread of our selected columns. ###Code # Reports the number of counts per class class_counts <- training_set %>% group_by(has_pd) %>% summarize(n = n()) class_counts ###Output _____no_output_____ ###Markdown Figure 7 A table displaying the balance in our training set ###Code options(repr.plot.width=4,repr.plot.height=4) class_counts_plot <- ggplot(class_counts, aes(x = has_pd, y = n, fill = has_pd)) + geom_bar(stat="identity") + labs(x = 'Has PD?', y = 'Number', fill = "Has PD") + ggtitle("Balance in PD Data Set") + theme(text = element_text(size = 18), legend.position = "none") class_counts_plot ###Output _____no_output_____ ###Markdown Figure 8 Visualizing the balance in our training set using a bar chart We had many more—almost three times as many—patients with PD than without in this data set. Therefore, we could conclude our training set was somewhat imbalanced (in fact, it was the same imbalance as the original data set thanks to `createDataPartition()` handling stratification for us); however, it was not severe enough to warrant use of `upScale()`. This limitation is further discussed at the end of our analysis. ###Code # Reports the means, maxes, and mins of each predictor variable used predictor_max <- training_set %>% select(PPE:locShimmer) %>% map_df(~ max(., na.rm = TRUE)) predictor_min <- training_set %>% select(PPE:locShimmer) %>% map_df(~ min(., na.rm = TRUE)) predictor_mean <- training_set %>% select(PPE:locShimmer) %>% map_df(~ mean(., na.rm = TRUE)) stats_merged <- rbind(predictor_max, predictor_min, predictor_mean) stat <- c('max','mean','min') stats_w_names <- data.frame(stat, stats_merged) predictor_stats <- gather(stats_w_names, key = variable, value = value, PPE:locShimmer) predictor_stats ###Output _____no_output_____ ###Markdown Figure 9 A table containing the mean, max, and min of each of our predictor variables Predictors in detail ###Code # Visualizes and compares the distributions of each of the predictor variables plot_pairs <- training_set %>% select(PPE:locShimmer) %>% ggpairs(title = "PD speech predictor variable correlations") # plot_pairs plot_pairs_by_class <- training_set %>% ggpairs(., legend = 9, columns = 2:8, mapping = ggplot2::aes(colour=has_pd), lower = list(continuous = wrap("smooth", alpha = 0.3, size=0.1)), title = "PD speech predictor variable correlations by class") + theme(legend.position = "bottom") # plot_pairs_by_class ###Output _____no_output_____ ###Markdown The following two plots were created using the `GGPairs` library. The first, without color, strictly provides detail about the distribution and correlation between each pair created from our six predictor variables. Three of our predictors, DFA, RPDE, and meanPeriodPulses take on a much wider range of values than PPE, jitter, and shimmer. Many of our variables exhibit somewhat positive correlations on the scatterplot, though some have an entirely fuzzy distribution. For example, compare the plots in the PPE column to those in the RPDE column. This likely comes as a result of the spread of the predictors. ###Code options(repr.plot.width=10,repr.plot.height=10, repr.plot.pointsize=20) plot_pairs ###Output _____no_output_____ ###Markdown Figure 10 A pairwise visualization exploring the relationships between our predictor variables With this understanding, we used a second plot, grouped and colored by `has_pd`, to assist in anticipating what the impact of these predictors would be. We noted that for every individual distribution, there is a marked difference between the red and blue groupings, which boded well for our analysis. On average, the healthy patients (i.e., `has_pd == FALSE`) fell on the lower end of the spectrum for our predictors, apart from PPE, where healthy patients exhibited higher values on average. Though we weren’t able to visualize our final model directly (as it was in six dimensions), we predicted from these plots that the new patients which fell on the "lower end" for most of these variables would be healthy. This also made intuitive sense; Parkinson’s is a degenerative disease for the muscles, so unhealthy patients would likely experience more rapid change in various speech variables due to tremors. ###Code options(repr.plot.width=10,repr.plot.height=10, repr.plot.pointsize=20) plot_pairs_by_class ###Output `stat_bin()` using `bins = 30`. Pick better value with `binwidth`. `stat_bin()` using `bins = 30`. Pick better value with `binwidth`. `stat_bin()` using `bins = 30`. Pick better value with `binwidth`. `stat_bin()` using `bins = 30`. Pick better value with `binwidth`. `stat_bin()` using `bins = 30`. Pick better value with `binwidth`. `stat_bin()` using `bins = 30`. Pick better value with `binwidth`. ###Markdown Figure 11 Another visualization of the relationship between our predictors, now with their class distributions considered 4 Hypothesis Expected OutcomesFrom our analysis, we expected to find that the six variables of speech we identified could form an effective model for determining whether or not a patient has Parkinson’s. We anticipated our findings would allow us to make reasonable predictions of whether or not a new patient has PD given their speech data. 5 Analysis Classification & Visualization Using all predictors from proposalBelow is our first attempt at constructing a classification model using all predictors from the proposal. ###Code # Scale the data set (pre-processing) scale_transformer <- preProcess(training_set, method = c("center", "scale")) training_set <- predict(scale_transformer, training_set) testing_set <- predict(scale_transformer, testing_set) # head(training_set) # head(testing_set) X_train <- training_set %>% select(-class, -has_pd) %>% data.frame() X_test <- testing_set %>% select(-class, -has_pd) %>% data.frame() Y_train <- training_set %>% select(class) %>% unlist() Y_test <- testing_set %>% select(class) %>% unlist() # head(X_train) # head(Y_train) train_control <- trainControl(method="cv", number = 10) k <- data.frame(k = seq(from = 1, to = 51, by = 2)) knn_model_cv_10fold <- train(x = X_train, y = Y_train, method = "knn", tuneGrid = k, trControl = train_control) # knn_model_cv_10fold accuracies <- knn_model_cv_10fold$results head(accuracies) ###Output _____no_output_____ ###Markdown Figure 12 A table containing the accuracy values for our first few values of k ###Code options(repr.plot.height = 5, repr.plot.width = 5) accuracy_vs_k <- ggplot(accuracies, aes(x = k, y = Accuracy)) + geom_point() + geom_line() + ggtitle("Graphing Accuracy Against K") + labs(subtitle = "Initial attempt—all predictors used") accuracy_vs_k ###Output _____no_output_____ ###Markdown Figure 13 A plot of accuracies of various k-values for a 10-fold cross-validation ###Code k <- accuracies %>% arrange(desc(Accuracy)) %>% head(n = 1) %>% select(k) k ###Output _____no_output_____ ###Markdown Figure 14 A table containing the optimal choice of k It looks like a choice of 5 here yields the high accuracy value. After approximately a k value of 40, our accuracy plateaus at just above 0.75. We will now retrain our model using this choice of k. ###Code k = data.frame(k = 5) model_knn <- train(x = X_train, y = Y_train, method = "knn", tuneGrid = k) # model_knn Y_test_predicted <- predict(object = model_knn, X_test) # head(Y_test_predicted) model_quality <- confusionMatrix(data = Y_test_predicted, reference = Y_test) model_quality ###Output _____no_output_____ ###Markdown Figure 15 Our final model statistics for our data set with all predictors Our final model had an accuracy of 79.4%, which is pretty good! Give our model is in six dimensions, there is no simple visualization for it. However, we can visualize whether or not our model had more false positives or false negatives, and which it was better are predicting: sick or healthy. The confusion matrix gives us all of these values in a 2x2 grid. ###Code # Create a dataset matrix_table <- as.data.frame(model_quality$table) %>% mutate(isCorrect = (Prediction == Reference)) # matrix_table matrix_plot <- ggplot(matrix_table, aes(fill = isCorrect, x = Reference, y = Freq)) + geom_bar(position="stack", stat="identity", width = 0.7) + labs(title = "Confusion Matrix Bar Chart", y = "Frequency", x = "Has PD?") + scale_fill_discrete(name="Correction Prediction?") matrix_plot ###Output _____no_output_____
hongong Python/review_self study Python 05_2021.04.02.fri.ipynb
###Markdown 함수 5-1 함수 만들기- 호출, 매개변수, 리턴값, 가변 매개변수, 기본 매개변수 - 함수 호출: 함수를 사용하는 것 (input)- 매개변수: 함수 호출 시 넣게 되는 자료 (fuc, 전처리)- 리턴값: 함수 호출로 최종적으로 나오는 결과 (output) 함수의 기본- def 함수 이름():- ㅁㅁㅁㅁ 문장 기본적인 함수 ###Code def print_3_times(): print("안녕하세요") print("안녕하세요") print("안녕하세요") print_3_times() ###Output 안녕하세요 안녕하세요 안녕하세요 ###Markdown 함수에 매개변수 - def 함수 이름(매개변수, 매개변수, ...):- ㅁㅁㅁㅁ문장 매개변수의 기본 ###Code def print_n_times(value, n): for i in range(n): print(value) print_n_times("안녕하세요", 5) # 매개변수는 덜 넣거나 더 넣으면 타입에러 뜸 ###Output 안녕하세요 안녕하세요 안녕하세요 안녕하세요 안녕하세요 ###Markdown 가변 매개변수- 매개변수를 원하는만큼 받을 수 있는 함수- def 함수 이름(매개변수, 매개변수, ..., *가변 매개변수):- ㅁㅁㅁㅁ문장- 가변 매개변수 뒤에는 일반 매개변수가 올 수 없고,- 하나만 사용할 수 있음 가변 매개변수 함수 ###Code def print_n_times(n, *values): # n번 반복 for i in range(n): # value는 리스트처럼 활용 for value in values: print(value) #줄바꿈 print() #함수 호출 print_n_times(3, "안녕하세요", "즐거운", "파이썬 프로그램") ###Output 안녕하세요 즐거운 파이썬 프로그램 안녕하세요 즐거운 파이썬 프로그램 안녕하세요 즐거운 파이썬 프로그램 ###Markdown 기본 매개변수- '매개변수 = 값'- 기본 미개변수 뒤에는 일반 매개변수가 올 수 없다. 기본 매개변수 ###Code def print_n_times(value, n=2): # n번 반복 for i in range(n): print(value) # 함수 호출 print_n_times("안녕하세요") ###Output 안녕하세요 안녕하세요 ###Markdown 기본 매개변수가 가변 매개변수보다 앞에 올 때 (에러) ###Code def print_n_times(n=2, *values): #n번 반복 for i in range(n): # values는 리스트처럼 활용 for value in values: print(value) # 단순한 줄바꿈 print() # 함수 호출 print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍") ###Output _____no_output_____ ###Markdown 가변 매개변수가 기본 매개변수보다 앞에 올때 ###Code def print_n_times(*values, n=2): #n번 반복 for i in range(n): # values는 리스트처럼 활용 for value in values: print(value) # 단순한 줄바꿈 print() # 함수 호출 print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍") ###Output 안녕하세요 즐거운 파이썬 프로그래밍 안녕하세요 즐거운 파이썬 프로그래밍 ###Markdown 키워드 매개변수 ###Code def print_n_times(*values, n=2): #n번 반복 for i in range(n): # values는 리스트처럼 활용 for value in values: print(value) # 단순한 줄바꿈 print() # 함수 호출 print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍", n=3) # 매개변수 이름을 지정해서 입력하는 매개변수 ###Output 안녕하세요 즐거운 파이썬 프로그래밍 안녕하세요 즐거운 파이썬 프로그래밍 안녕하세요 즐거운 파이썬 프로그래밍 ###Markdown 기본 매개변수 중에서 필요한 값만 입력하기 여러 함수 호출 형태 ###Code def test(a, b=10, c=100): print(a+b+c) # 1) 기본 형태 test(10,20,30) # 2) 키워드 매개변수로 모든 매개변수를 지정한 형태 test(a=10, b=100, c=200) # 3) 키워드 매개변수로 모든 매개변수를 마구잡이로 지정한 형태 test(c=10, a=100, b=200) # 4) 키워드 매개변수로 일부 매개변수만 지정한 형태 test(10, c=200) ###Output 60 310 310 220 ###Markdown 리턴return 자료 없이 리턴하기 ###Code def return_test(): print("A 위치 입니다.") return # 리턴 print("B 위치 입니다.") # 함수 호출 return_test() ###Output A 위치 입니다. ###Markdown 자료와 함께 리턴하기 ###Code def return_test(): return 100 # 리턴 # 함수 호출 value = return_test() print(value) ###Output 100 ###Markdown 아무 것도 리턴하지 않았을 때의 리턴값 ###Code # 함수 정의 def return_test(): return # 함수 호출 value = return_test() print(value) ###Output None ###Markdown 기본적인 함수의 활용- def 함수(매개변수):- ㅁㅁㅁㅁ변수 = 초깃값- ㅁㅁㅁㅁ 여러 가지 처리- ㅁㅁㅁㅁ 여러 가지 처리- ㅁㅁㅁㅁ 여러 가지 처리- ㅁㅁㅁㅁreturn 범위 내부의 정수를 모두 더하는 함수 ###Code # 함수 선언 def sum_all(start,end): # 변수 선언 output = 0 # 반복문 돌려 숫자 더하기 for i in range(start, end+1): output+= i # 리턴 return output # 함수 호출 print("0 to 100:", sum_all(0,100)) print("0 to 1000:", sum_all(0,1000)) print("50 to 100:", sum_all(50,100)) print("500 to 1000:", sum_all(500,1000)) ###Output 0 to 100: 5050 0 to 1000: 500500 50 to 100: 3825 500 to 1000: 375750 ###Markdown 기본 매개변수와 키워드 매개변수를 활용해 범위의 정수를 더하는 함수 ###Code # 함수 선언 def sum_all(start=0, end=100, step=1): # 변수 선언 output = 0 # 반복문 돌려 숫자 더하기 for i in range(start, end+1,step): output+= i # 리턴 return output # 함수 호출 print("A.", sum_all(0,100,10)) print("B.", sum_all(end=100)) print("C.", sum_all(end=100, step=2)) ###Output A. 550 B. 5050 C. 2550 ###Markdown 핵심포인트- 호출: 함수를 실행하는 행위- 매개변수: 함수의 괄호 내부에 넣는 것- 리턴값: 함수의 최종적인 결과- 가변 매개변수 함수: 매개변수를 원하는 만큼 받을 수 있는 함수- 기본 매개변수: 매개변수에 아무것도 넣지 않아도 들어가는 값 확인문제 ###Code # f(x) = 2x+1 def f(x): return 2*int(x)+1 print(f(10)) # f(x) = x^2+2x+1 def f(x): return int(x)**2+2*int(x)+1 print(f(10)) # 매개변수로 전달된 값들을 모두 곱해서 리턴하는 가변 매개변수 함수 만들기 # 실행결과 3150 def mul(*values): output = 1 for value in values: output *= value return output print(mul(5, 7, 9, 10)) ###Output 3150
notebooks/Online Learning Fast.ipynb
###Markdown Prendiamo un elemento alla volta dal test, facciamo la similarità di quell'elemento ed estraiamo il top50. Quell'elemento poi verrà predetto. Una volta tirata fuori la predizione di quell'elemento, va aggiunto al train [di LightGBM]: non importa rifare la similarità perché valutando un elemento alla volta sappiamo già dalla similarità che facciamo se quell'elemento è nel train o no. ###Code df_train = pd.read_csv("../dataset/original/train.csv", escapechar="\\") df_test = pd.read_csv("../dataset/original/test.csv", escapechar="\\") df_train = df_train.sort_values(by='record_id').reset_index(drop=True) df_test = df_test.sort_values(by='record_id').reset_index(drop=True) df_train.linked_id = df_train.linked_id.astype(int) df_test['linked_id'] = df_test.record_id.str.split("-") df_test['linked_id'] = df_test.linked_id.apply(lambda x: x[0]) df_test.linked_id = df_test.linked_id.astype(int) #df_train.linked_id = df_train.linked_id.astype(int) only_test = set(df_test.linked_id.values) - set(df_train.linked_id.values) only_test_recordid = df_test[df_test.linked_id.isin(only_test)] df_test = df_test.drop('linked_id', axis=1) train1 = pd.read_csv("../dataset/validation_2/train_complete.csv") train2 = pd.read_csv("../dataset/validation_3/train_complete.csv") val = pd.read_csv("../dataset/validation/train_complete.csv") def remove_spaces(s, n=3): s = re.sub(' +',' ',s).strip() ngrams = zip(*[s[i:] for i in range(n)]) return [''.join(ngram) for ngram in ngrams] def ngrams_name(test_record, df_train): df_train.name = df_train.name.astype(str) test_record['name'] = test_record['name'].astype(str) corpus = list(df_train.name) corpus.append(test_record['name']) vectorizer = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X = vectorizer.fit_transform(corpus) X_train = X[:df_train.shape[0],:] X_test = X[df_train.shape[0]:,:] similarity = sim.jaccard(X_test, X_train.T, k=300) return similarity.tocsr() def ngrams_name_fast(test_record, vectorizer, X_train): # deve: # - prendere il nome del test # - vettorizzarlo # - calcolare la similarità # - ritornare la similarità con una nuova riga e una nuova colonna # - ritornare X_train con una nuova riga (la vettorizzazione del nuovo record) # ? X_test = vectorizer.transform([test_record['name']]) similarity = sim.jaccard(X_test, X_train.T, k=300).tocsr() return similarity.tocsr(), vstack([X_train,X_test]) def ngrams_address(test_record, df_train): df_train.address = df_train.address.fillna('').astype(str) test_record.address = test_record.fillna({'address':''}).address corpus = list(df_train.address) corpus.append(test_record.address) vectorizer = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X = vectorizer.fit_transform(corpus) X_train = X[:df_train.shape[0],:] X_test = X[df_train.shape[0]:,:] similarity = sim.jaccard(X_test, X_train.T, k=300) return similarity.tocsr() def ngrams_address_fast(test_record, vectorizer, X_train): test_record.address = test_record.fillna({'address':''}).address X_test = vectorizer.transform([test_record.address]) similarity = sim.jaccard(X_test, X_train.T, k=300) return similarity.tocsr(), vstack([X_train,X_test]) def ngrams_email(test_record, df_train): df_train.email = df_train.email.fillna('').astype(str) test_record.email = test_record.fillna({'email':''}).email corpus = list(df_train.email) corpus.append(test_record.email) vectorizer = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X = vectorizer.fit_transform(corpus) X_train = X[:df_train.shape[0],:] X_test = X[df_train.shape[0]:,:] similarity = sim.jaccard(X_test, X_train.T, k=300) return similarity.tocsr() def ngrams_email_fast(test_record, vectorizer, X_train): test_record.email = test_record.fillna({'email':''}).email X_test = vectorizer.transform([test_record.email]) similarity = sim.jaccard(X_test, X_train.T, k=300) return similarity.tocsr(), vstack([X_train,X_test]) def convert_phones(df_in): """ This functions transforms the phone column from scientific notation to readable string format, e.g. 1.2933+E10 to 12933000000 : param df_in : the original df with the phone in scientific notation : return : the clean df """ df = df_in.copy() df.phone = df.phone.fillna('').astype(str) df.phone = [p.split('.')[0] for p in df.phone] return df def ngrams_phone(test_record, df_train): # manually convert test_record phone if np.isnan(test_record.phone): test_record.phone = test_record.fillna({'phone':''}).phone else: test_record.phone = test_record.fillna({'phone':''}).phone.astype(str) test_record.phone = test_record.phone.split('.')[0] df_train = convert_phones(df_train) corpus = list(df_train.phone) corpus.append(test_record.phone) vectorizer = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X = vectorizer.fit_transform(corpus) X_train = X[:df_train.shape[0],:] X_test = X[df_train.shape[0]:,:] similarity = sim.jaccard(X_test, X_train.T, k=300) return similarity.tocsr() def ngrams_phone_fast(test_record, vectorizer, X_train): # manually convert test_record phone if np.isnan(test_record.phone): test_record.phone = test_record.fillna({'phone':''}).phone else: test_record.phone = test_record.fillna({'phone':''}).phone.astype(str) test_record.phone = test_record.phone.split('.')[0] X_test = vectorizer.transform([test_record.phone]) similarity = sim.jaccard(X_test, X_train.T, k=300) return similarity.tocsr(), vstack([X_train,X_test]) def expand_df(df): df_list = [] for (q, pred, pred_rec, score, s_name, s_email, s_phone, idx) in tqdm( zip(df.queried_record_id, df.predicted_record_id, df.predicted_record_id_record, df.cosine_score, df.name_cosine, df.email_cosine, df.phone_cosine, df.linked_id_idx)): for x in range(len(pred)): df_list.append((q, pred[x], pred_rec[x], score[x], s_name[x], s_email[x], s_phone[x], idx[x])) # TODO da cambiare predicted_record_id in predicted_linked_id e 'predicted_record_id_record' in 'predicted_record_id' df_new = pd.DataFrame(df_list, columns=['queried_record_id', 'predicted_record_id', 'predicted_record_id_record', 'cosine_score', 'name_cosine', 'email_cosine', 'phone_cosine', 'linked_id_idx', ]) return df_new def expand_similarities(test_record, vectorizer_name, vectorizer_email, vectorizer_phone, vectorizer_address, X_train_name, X_train_email, X_train_phone, X_train_address, k=50): sim_name, X_train_name_new = ngrams_name_fast(test_record, vectorizer_name, X_train_name) sim_email, X_train_email_new = ngrams_email_fast(test_record, vectorizer_email, X_train_email) sim_phone, X_train_phone_new = ngrams_phone_fast(test_record, vectorizer_phone, X_train_phone) sim_address, X_train_address_new = ngrams_address_fast(test_record, vectorizer_address, X_train_address) hybrid = sim_name + 0.2 * sim_email + 0.2 * sim_phone + 0.2 * sim_address linid_ = [] linid_idx = [] linid_score = [] linid_name_cosine = [] linid_email_cosine = [] linid_phone_cosine = [] linid_address_cosine = [] linid_record_id = [] tr = df_train[['record_id', 'linked_id']] indices = hybrid.nonzero()[1][hybrid.data.argsort()[::-1]][:k] df = tr.loc[indices, :][:k] linid_.append(df['linked_id'].values) linid_idx.append(df.index) linid_record_id.append(df.record_id.values) linid_score.append(np.sort(hybrid.data)[::-1][:k]) # Questo ha senso perché tanto gli indices sono sortati in base allo scores di hybrid linid_name_cosine.append([sim_name[0, t] for t in indices]) linid_email_cosine.append([sim_email[0, t] for t in indices]) linid_phone_cosine.append([sim_phone[0, t] for t in indices]) df = pd.DataFrame() df['queried_record_id'] = [test_record.record_id] df['predicted_record_id'] = linid_ df['predicted_record_id_record'] = linid_record_id df['cosine_score'] = linid_score df['name_cosine'] = linid_name_cosine df['email_cosine'] = linid_email_cosine df['phone_cosine'] = linid_phone_cosine df['linked_id_idx'] = linid_idx df_new = expand_df(df) return df_new, X_train_name_new, X_train_email_new, X_train_phone_new, X_train_address_new def get_linked_id(new_row): new_row['linked_id'] = new_row.record_id.split("-") new_row['linked_id'] = new_row.linked_id[0] new_row['linked_id'] = int(new_row.linked_id) return new_row def create_all_vectorizers(df_train): # vectorizer Name df_train.name = df_train.name.astype(str) corpus_name = list(df_train.name) vectorizer_name = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X_train_name = vectorizer_name.fit_transform(corpus_name) # vectorizer Email df_train.email = df_train.email.fillna('').astype(str) corpus_email = list(df_train.email) vectorizer_email = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X_train_email = vectorizer_email.fit_transform(corpus_email) # vectorizer Address df_train.address = df_train.address.fillna('').astype(str) corpus_address = list(df_train.address) vectorizer_address = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X_train_address = vectorizer_address.fit_transform(corpus_address) # vectorizer Phone df_train = convert_phones(df_train) corpus_phone = list(df_train.phone) vectorizer_phone = CountVectorizer(preprocessor = remove_spaces, analyzer=remove_spaces) X_train_phone = vectorizer_phone.fit_transform(corpus_phone) return vectorizer_name, vectorizer_email, vectorizer_address, vectorizer_phone, X_train_name, X_train_email, X_train_address, X_train_phone ###Output _____no_output_____ ###Markdown Train ###Code train = pd.concat([train1, train2]) eval_group = val.groupby('queried_record_id').size().values group = train.groupby('queried_record_id').size().values ranker = lgb.LGBMRanker() print('Start LGBM...') t1 = time.time() ranker.fit(train.drop(['queried_record_id', 'target', 'predicted_record_id','predicted_record_id_record', 'linked_id_idx'], axis=1), train['target'], group=group, eval_set=[(val.drop(['queried_record_id', 'target', 'predicted_record_id','predicted_record_id_record', 'linked_id_idx'], axis=1), val['target'])], eval_group=[eval_group], early_stopping_rounds=5) t2 = time.time() print(f'Learning completed in {int(t2-t1)} seconds.') ###Output Start LGBM... [1] valid_0's ndcg@1: 0.972762 Training until validation scores don't improve for 5 rounds. [2] valid_0's ndcg@1: 0.975492 [3] valid_0's ndcg@1: 0.977745 [4] valid_0's ndcg@1: 0.979941 [5] valid_0's ndcg@1: 0.980212 [6] valid_0's ndcg@1: 0.98034 [7] valid_0's ndcg@1: 0.980388 [8] valid_0's ndcg@1: 0.981028 [9] valid_0's ndcg@1: 0.980887 [10] valid_0's ndcg@1: 0.982163 [11] valid_0's ndcg@1: 0.982491 [12] valid_0's ndcg@1: 0.982518 [13] valid_0's ndcg@1: 0.982995 [14] valid_0's ndcg@1: 0.983013 [15] valid_0's ndcg@1: 0.983066 [16] valid_0's ndcg@1: 0.98335 [17] valid_0's ndcg@1: 0.983762 [18] valid_0's ndcg@1: 0.983911 [19] valid_0's ndcg@1: 0.984109 [20] valid_0's ndcg@1: 0.984468 [21] valid_0's ndcg@1: 0.984486 [22] valid_0's ndcg@1: 0.984516 [23] valid_0's ndcg@1: 0.984564 [24] valid_0's ndcg@1: 0.984748 [25] valid_0's ndcg@1: 0.984889 [26] valid_0's ndcg@1: 0.985003 [27] valid_0's ndcg@1: 0.984911 [28] valid_0's ndcg@1: 0.985016 [29] valid_0's ndcg@1: 0.98516 [30] valid_0's ndcg@1: 0.985187 [31] valid_0's ndcg@1: 0.985288 [32] valid_0's ndcg@1: 0.985283 [33] valid_0's ndcg@1: 0.985331 [34] valid_0's ndcg@1: 0.985336 [35] valid_0's ndcg@1: 0.985463 [36] valid_0's ndcg@1: 0.985406 [37] valid_0's ndcg@1: 0.98545 [38] valid_0's ndcg@1: 0.98552 [39] valid_0's ndcg@1: 0.985524 [40] valid_0's ndcg@1: 0.985638 [41] valid_0's ndcg@1: 0.985713 [42] valid_0's ndcg@1: 0.985713 [43] valid_0's ndcg@1: 0.98577 [44] valid_0's ndcg@1: 0.985783 [45] valid_0's ndcg@1: 0.985853 [46] valid_0's ndcg@1: 0.985862 [47] valid_0's ndcg@1: 0.985919 [48] valid_0's ndcg@1: 0.985962 [49] valid_0's ndcg@1: 0.986019 [50] valid_0's ndcg@1: 0.986041 [51] valid_0's ndcg@1: 0.986111 [52] valid_0's ndcg@1: 0.986133 [53] valid_0's ndcg@1: 0.986221 [54] valid_0's ndcg@1: 0.986208 [55] valid_0's ndcg@1: 0.986256 [56] valid_0's ndcg@1: 0.986278 [57] valid_0's ndcg@1: 0.986313 [58] valid_0's ndcg@1: 0.986269 [59] valid_0's ndcg@1: 0.986282 [60] valid_0's ndcg@1: 0.986243 [61] valid_0's ndcg@1: 0.98626 [62] valid_0's ndcg@1: 0.986304 Early stopping, best iteration is: [57] valid_0's ndcg@1: 0.986313 Learning completed in 342 seconds. ###Markdown Example ###Code vectorizer_name, vectorizer_email, vectorizer_address, vectorizer_phone, X_train_name, X_train_email, X_train_address, X_train_phone= create_all_vectorizers(df_train) t1 = time.time() test_record_exp, X_train_name_new, X_train_email_new, X_train_phone_new, X_train_address_new = expand_similarities(df_test.loc[2], vectorizer_name, vectorizer_email, vectorizer_phone, vectorizer_address, X_train_name, X_train_email, X_train_phone, X_train_address) t2 = time.time() t2-t1 test_record_exp ###Output _____no_output_____ ###Markdown Create Sequential Test Answers Dobbiamo creare un test set sequenziale [con le relative risposte], in modo che se ci sono due record che fanno riferimento allo stesso linked_id che però sono presenti solo nel test, il primo che arriva non ha riferimenti nel train ed è impossibile predirlo correttamente; viene però aggiunto al train e quando il secondo record deve essere valutato la risposta corretta corrisponde a quello precedente. ###Code group_train = df_train.groupby('linked_id').apply(lambda x: list(x['record_id'])).reset_index().rename(columns={0:'record_ids'}) df_test df_test['linked_id'] = df_test.record_id.str.split('-') df_test['linked_id'] = df_test.linked_id.apply(lambda x: x[0]) df_test.linked_id = df_test.linked_id.astype(int) df_test = df_test.merge(group_train, how= 'left', on='linked_id') def seq_labelling(df): linked_seen = [] new_group = { } new_df = [] df_notna = df[~df.record_ids.isna()] df_na = df[df.record_ids.isna()] relevant_idx= [] for (i, l, r) in tqdm(zip(df_na.index, df_na.linked_id, df_na.record_id)): if l not in linked_seen: linked_seen.append(l) new_df.append((i, r, np.nan)) new_group[l] = [r] else: current_group = new_group[l] #print(f'{r} and the group: {current_group}') new_df.append((i, r, current_group)) new_group[l].append(r) relevant_idx.append(i) res = pd.DataFrame(new_df, columns=['index','record_id', 'record_ids']).set_index('index') full_df = pd.concat([df_notna, res]) full_df = full_df.sort_index() return full_df, relevant_idx def get_target(df): df, idx = seq_labelling(df) df_notidx = df.loc[~df.index.isin(idx)] df = df.loc[idx] new_df = [] for (i,r, g) in tqdm(zip(df.index, df.record_id, df.record_ids)): idx = g.index(r) g = g[:idx] new_df.append((i, r, g)) new_df = pd.DataFrame(new_df, columns=['index','record_id', 'record_ids']).set_index('index') res = pd.concat([new_df, df_notidx]) res = res.sort_index() return res seq = get_target(df_test[['record_id', 'linked_id','record_ids']]) ###Output _____no_output_____ ###Markdown Incremental Evaluation NotaInvece di fare le predizioni su tutto il test, visto che sappiamo come performa l'algoritmo classico su quei record che hanno riferimenti nel train, possiamo restringere l'analisi ai record del test che non hanno riferimenti nel train e che hanno duplicati all'interno del test stesso [per quelli che non sono duplicati non ha senso fare tale analisi perché non forniscono nessun contributo alle query successive] ###Code duplicates_df = only_test_recordid[only_test_recordid.duplicated('linked_id', keep=False)] duplicates_df idx = duplicates_df.index def reorder_preds(preds): ordered_lin = [] ordered_score = [] ordered_record = [] for i in range(len(preds)): l = sorted(preds[i], key=lambda t: t[1], reverse=True) lin = [x[0] for x in l] s = [x[1] for x in l] r = [x[2] for x in l] ordered_lin.append(lin) ordered_score.append(s) ordered_record.append(r) return ordered_lin, ordered_score, ordered_record # Re-load training set df_train = pd.read_csv("../dataset/original/train.csv", escapechar="\\") df_train = df_train.sort_values(by='record_id').reset_index(drop=True) df_train.linked_id = df_train.linked_id.astype(int) # get vectorizers vectorizer_name, vectorizer_email, vectorizer_address, vectorizer_phone, X_train_name, X_train_email, X_train_address, X_train_phone= create_all_vectorizers(df_train) # Online Learning -------------> TODO: ci mette troppo, circa 7ore test_prediction = pd.DataFrame() seen = [] for i in tqdm(idx): test_row = duplicates_df.loc[i] print(f'Record: {test_row.record_id}') t1 = time.time() #print(f'Extract test record at index: {i}') # Get the test record to be evaluate #print('Create Features') test_row_exp, X_train_name, X_train_email, X_train_phone, X_train_address = expand_similarities(test_row, vectorizer_name, vectorizer_email, vectorizer_phone, vectorizer_address, X_train_name, X_train_email, X_train_phone, X_train_address) test_row_exp = adding_features(test_row_exp, isValidation=False, path=os.path.join('..', 'dataset', 'original'), incremental_train=df_train) # Get predictions #print('Get Predictions') predictions = ranker.predict(test_row_exp.drop(['queried_record_id','linked_id_idx', 'predicted_record_id','predicted_record_id_record'], axis=1)) test_row_exp['predictions'] = predictions df_predictions = test_row_exp[['queried_record_id', 'predicted_record_id', 'predicted_record_id_record', 'predictions']] # Re-order predictions #print('Reorder Predictions') rec_pred = [] for (l,p,record_id) in zip(df_predictions.predicted_record_id, df_predictions.predictions, df_predictions.predicted_record_id_record): rec_pred.append((l, p, record_id)) df_predictions['rec_pred'] = rec_pred group_queried = df_predictions[['queried_record_id', 'rec_pred']].groupby('queried_record_id').apply(lambda x: list(x['rec_pred'])) df_predictions = pd.DataFrame(group_queried).reset_index().rename(columns={0 : 'rec_pred'}) # Store predictions #print('Store Predictions') df_predictions['ordered_linked'], df_predictions['ordered_scores'], df_predictions['ordered_record'] = reorder_preds(df_predictions.rec_pred.values) test_prediction = pd.concat([test_prediction, df_predictions], ignore_index=True) new_row = get_linked_id(test_row) df_train = df_train.append(new_row, ignore_index=True) t2 = time.time() #print(f'Iteration completed in {t2 - t1}s') test_prediction ###Output _____no_output_____
SVM _updated (1) (1).ipynb
###Markdown ASSIGNMENT - SUPPORT VECTOR MACHINE( SVM ) [1] READING DATA ###Code import pandas as pd project_data=pd.read_csv("Donor_choose/train_data.csv") resource_data=pd.read_csv("Donor_choose/resources.csv") ###Output _____no_output_____ ###Markdown [2] Sorting data according to time [TBS] ###Code # how to replace elements in list python: https://stackoverflow.com/a/2582163/4084039 cols=['Date' if x=='project_submitted_datetime'else x for x in list(project_data.columns)] #sort dataframe based on time pandas python: https://stackoverflow.com/a/49702492/4084039 project_data['Date'] = pd.to_datetime(project_data['project_submitted_datetime']) project_data.drop('project_submitted_datetime', axis=1, inplace=True) project_data.sort_values(by=['Date'], inplace=True) # how to reorder columns pandas python: https://stackoverflow.com/a/13148611/4084039 project_data = project_data[cols] print(cols) project_data.head(2) print(project_data.shape) print("="*100) print(project_data.columns.values) print("="*100) print(resource_data.shape) print("="*100) print(resource_data.columns.values) ###Output (109248, 17) ==================================================================================================== ['Unnamed: 0' 'id' 'teacher_id' 'teacher_prefix' 'school_state' 'Date' 'project_grade_category' 'project_subject_categories' 'project_subject_subcategories' 'project_title' 'project_essay_1' 'project_essay_2' 'project_essay_3' 'project_essay_4' 'project_resource_summary' 'teacher_number_of_previously_posted_projects' 'project_is_approved'] ==================================================================================================== (1541272, 4) ==================================================================================================== ['id' 'description' 'quantity' 'price'] ###Markdown [3] Preproccesing Steps ###Code categories=list(project_data['project_subject_categories'].values) # remove special characters from list of strings python: https://stackoverflow.com/a/47301924/4084039 cat_list = [] for i in categories: temp = "" # consider we have text like this "Math & Science, Warmth, Care & Hunger" for j in i.split(','): # it will split it in three parts ["Math & Science", "Warmth", "Care & Hunger"] if 'The' in j.split(): # this will split each of the catogory based on space "Math & Science"=> "Math","&", "Science" j=j.replace('The','') # if we have the words "The" we are going to replace it with ''(i.e removing 'The') j = j.replace(' ','') # we are placeing all the ' '(space) with ''(empty) ex:"Math & Science"=>"Math&Science" temp+=j.strip()+" " #" abc ".strip() will return "abc", remove the trailing spaces temp = temp.replace('&','_') # we are replacing the & value into cat_list.append(temp.strip()) project_data['clean_categories'] = cat_list project_data.drop(['project_subject_categories'], axis=1, inplace=True) project_data.head(2) # count of all the words in corpus python: https://stackoverflow.com/a/22898595/4084039 from collections import Counter my_counter = Counter() for word in project_data['clean_categories'].values: my_counter.update(word.split()) # dict sort by value python: https://stackoverflow.com/a/613218/4084039 cat_dict = dict(my_counter) sorted_cat_dict = dict(sorted(cat_dict.items(), key=lambda kv: kv[1])) sorted_cat_dict sub_catogories = list(project_data['project_subject_subcategories'].values) # remove special characters from list of strings python: https://stackoverflow.com/a/47301924/4084039 # https://www.geeksforgeeks.org/removing-stop-words-nltk-python/ # https://stackoverflow.com/questions/23669024/how-to-strip-a-specific-word-from-a-string # https://stackoverflow.com/questions/8270092/remove-all-whitespace-in-a-string-in-python sub_cat_list = [] for i in sub_catogories: temp = "" # consider we have text like this "Math & Science, Warmth, Care & Hunger" for j in i.split(','): # it will split it in three parts ["Math & Science", "Warmth", "Care & Hunger"] if 'The' in j.split(): # this will split each of the catogory based on space "Math & Science"=> "Math","&", "Science" j=j.replace('The','') # if we have the words "The" we are going to replace it with ''(i.e removing 'The') j = j.replace(' ','') # we are placeing all the ' '(space) with ''(empty) ex:"Math & Science"=>"Math&Science" temp +=j.strip()+" "#" abc ".strip() will return "abc", remove the trailing spaces temp = temp.replace('&','_') sub_cat_list.append(temp.strip()) project_data['clean_subcategories'] = sub_cat_list project_data.drop(['project_subject_subcategories'], axis=1, inplace=True) project_data.head(2) # count of all the words in corpus python: https://stackoverflow.com/a/22898595/4084039 from collections import Counter my_counter = Counter() for word in project_data['clean_subcategories'].values: my_counter.update(word.split()) # dict sort by value python: https://stackoverflow.com/a/613218/4084039 sub_cat_dict = dict(my_counter) sorted_sub_cat_dict = dict(sorted(sub_cat_dict.items(), key=lambda kv: kv[1])) sorted_sub_cat_dict # merge two column text dataframe: project_data["essay"] = project_data["project_essay_1"].map(str) +\ project_data["project_essay_2"].map(str) + \ project_data["project_essay_3"].map(str) + \ project_data["project_essay_4"].map(str) print(project_data["essay"].value_counts) project_data.head(2) # we get the cost of the project using resource.csv file resource_data.head(2) price_data = resource_data.groupby('id').agg({'price':'sum', 'quantity':'sum'}).reset_index() price_data.head(2) # join two dataframes in python: project_data = pd.merge(project_data, price_data, on='id', how='left') approved_price = project_data[project_data['project_is_approved']==1]['price'].values rejected_price = project_data[project_data['project_is_approved']==0]['price'].values # http://zetcode.com/python/prettytable/ from prettytable import PrettyTable import numpy as np t = PrettyTable() t.field_names = ["Percentile", "Approved Projects", "Not Approved Projects"] for i in range(0,101,5): t.add_row([i,np.round(np.percentile(approved_price,i), 3), np.round(np.percentile(rejected_price,i), 3)]) print(t) project_data.head(2) # https://stackoverflow.com/a/47091490/4084039 import re def decontracted(phrase): # specific phrase = re.sub(r"won't", "will not", phrase) phrase = re.sub(r"can\'t", "can not", phrase) # general phrase = re.sub(r"n\'t", " not", phrase) phrase = re.sub(r"\'re", " are", phrase) phrase = re.sub(r"\'s", " is", phrase) phrase = re.sub(r"\'d", " would", phrase) phrase = re.sub(r"\'ll", " will", phrase) phrase = re.sub(r"\'t", " not", phrase) phrase = re.sub(r"\'ve", " have", phrase) phrase = re.sub(r"\'m", " am", phrase) return phrase import nltk from nltk.corpus import stopwords from nltk.stem import PorterStemmer from nltk.stem.wordnet import WordNetLemmatizer stopWords = set(stopwords.words('english')) print(stopWords) sno=nltk.stem.SnowballStemmer('english') print(sno.stem('amazing')) # PREPROCESSING FOR ESSAYS from tqdm import tqdm import re import string from bs4 import BeautifulSoup preprocessed_essays = [] # tqdm is for printing the status bar for sentance in tqdm(project_data['essay'].values): sent = decontracted(sentance) sent = sent.replace('\\r', ' ') sent = sent.replace('\\"', ' ') sent = sent.replace('\\n', ' ') sent = re.sub('[^A-Za-z0-9]+', ' ', sent) sent = re.sub("\S*\d\S*", "", sent).strip() # https://gist.github.com/sebleier/554280 sent = ' '.join(e for e in sent.split() if e not in stopWords) preprocessed_essays.append(sent.lower().strip()) # After preprocessing preprocessed_essays[2000] project_data = pd.DataFrame(project_data) project_data['cleaned_essays'] = preprocessed_essays project_data.head(2) # Data preprocessing on title text from tqdm import tqdm import re import string from bs4 import BeautifulSoup preprocessed_title_text = [] # tqdm is for printing the status bar for sentance in tqdm(project_data['project_title'].values): sent = decontracted(sentance) sent = sent.replace('\\r', ' ') sent = sent.replace('\\"', ' ') sent = sent.replace('\\n', ' ') sent = re.sub('[^A-Za-z0-9]+', ' ', sent) sent = re.sub("\S*\d\S*", "", sent).strip() # https://gist.github.com/sebleier/554280 sent = ' '.join(e for e in sent.split() if e not in stopWords) preprocessed_title_text.append(sent.lower().strip()) project_data = pd.DataFrame(project_data) project_data['cleaned_title_text'] = preprocessed_title_text project_data.head(2) print(project_data.shape) print(project_data.columns) # Fill blank spaces of teacher_prefix with nan #https://stackoverflow.com/questions/42224700/attributeerror-float-object-has-no-attribute-split project_data['teacher_prefix'] = project_data['teacher_prefix'].fillna('null') project_data.head(2) # count of all the words in corpus python: https://stackoverflow.com/a/22898595/4084039 from collections import Counter my_counter = Counter() for word in project_data['project_grade_category'].values: my_counter.update(word.split()) project_grade_category_dict = dict(my_counter) project_grade_category_dict = dict(sorted(project_grade_category_dict.items(), key=lambda kv: kv[1])) ###Output _____no_output_____ ###Markdown Train Test split ###Code project_data.shape project_data["project_is_approved"].value_counts() # Randomly sample 50k points project_data = project_data.sample(n=50000) project_data.shape # Define x & y for splitting y=project_data['project_is_approved'].values project_data.drop(['project_is_approved'], axis=1, inplace=True) # drop project is approved columns x=project_data print(y.shape) print(x.shape) x.head(2) # break in train test from sklearn.model_selection import train_test_split x_train,x_test,y_train,y_test= train_test_split(x,y,test_size=0.3,random_state=2,shuffle=False) # now break trainig data further in train and cv #x_train,x_cv,y_train,y_cv= train_test_split(x_train, y_train, test_size=0.3 ,random_state=2,stratify=y_train) print(x_train.shape, y_train.shape) #print(x_cv.shape, y_cv.shape) print(x_test.shape, y_test.shape) print("="*100) x=np.count_nonzero(y_test) # count no. of project app or not on test data set print(len(y_test)-x) print(x) x_train.head(2) ###Output _____no_output_____ ###Markdown Apply BOW and OHE ###Code from sklearn.feature_extraction.text import CountVectorizer # Vectorizing text data # We are considering only the words which appeared in at least 10 documents(rows or projects). vectorizer = CountVectorizer(min_df=10,ngram_range=(1,2)) vectorizer.fit_transform(x_train["cleaned_essays"].values) x_train_essay_bow = vectorizer.transform(x_train['cleaned_essays'].values) #x_cv_essay_bow = vectorizer.transform(x_cv['cleaned_essays'].values) x_test_essay_bow = vectorizer.transform(x_test['cleaned_essays'].values) print("After vectorizations") print(x_train_essay_bow.shape, y_train.shape) #print(x_cv_essay_bow.shape, y_cv.shape) print(x_test_essay_bow.shape, y_test.shape) print("="*100) # BOW on clean_titles from sklearn.feature_extraction.text import CountVectorizer vectorizer = CountVectorizer(min_df=10,ngram_range=(1,2)) vectorizer.fit(x_train['cleaned_title_text'].values) # fit has to happen only on train data # we use the fitted CountVectorizer to convert the text to vector x_train_titles_bow = vectorizer.transform(x_train['cleaned_title_text'].values) #x_cv_titles_bow = vectorizer.transform(x_cv['cleaned_title_text'].values) x_test_titles_bow = vectorizer.transform(x_test['cleaned_title_text'].values) print("After vectorizations") print(x_train_titles_bow.shape, y_train.shape) #print(x_cv_titles_bow.shape, y_cv.shape) print(x_test_titles_bow.shape, y_test.shape) print("="*100) # ONE of subject category from sklearn.feature_extraction.text import CountVectorizer vectorizer = CountVectorizer() vectorizer.fit(x_train['clean_categories'].values) # fit has to happen only on train data # we use the fitted CountVectorizer to convert the text to vector x_train_clean_cat_ohe = vectorizer.transform(x_train['clean_categories'].values) #x_cv_clean_cat_ohe = vectorizer.transform(x_cv['clean_categories'].values) x_test_clean_cat_ohe = vectorizer.transform(x_test['clean_categories'].values) print("After vectorizations") print(x_train_clean_cat_ohe.shape, y_train.shape) #print(x_cv_clean_cat_ohe.shape, y_cv.shape) print(x_test_clean_cat_ohe.shape, y_test.shape) print(vectorizer.get_feature_names()) print("="*100) # ONE of subject subcategory vectorizer = CountVectorizer() vectorizer.fit(x_train['clean_subcategories'].values) # fit has to happen only on train data # we use the fitted CountVectorizer to convert the text to vector x_train_clean_subcat_ohe = vectorizer.transform(x_train['clean_subcategories'].values) #x_cv_clean_subcat_ohe = vectorizer.transform(x_cv['clean_subcategories'].values) x_test_clean_subcat_ohe = vectorizer.transform(x_test['clean_subcategories'].values) print("After vectorizations") print(x_train_clean_cat_ohe.shape, y_train.shape) #print(x_cv_clean_cat_ohe.shape, y_cv.shape) print(x_test_clean_cat_ohe.shape, y_test.shape) print(vectorizer.get_feature_names()) print("="*100) # one hot encoding the catogorical features: categorical_categories # teacher_prefix vectorizer = CountVectorizer() vectorizer.fit(x_train['teacher_prefix'].values) # fit has to happen only on train data # we use the fitted CountVectorizer to convert the text to vector x_train_teacher_pre = vectorizer.transform(x_train['teacher_prefix'].values) #x_cv_teacher_pre = vectorizer.transform(x_cv['teacher_prefix'].values) x_test_teacher_pre = vectorizer.transform(x_test['teacher_prefix'].values) print("After vectorizations") print(x_train_teacher_pre.shape, y_train.shape) #print(x_cv_teacher_pre.shape, y_cv.shape) print(x_test_teacher_pre.shape, y_test.shape) print(vectorizer.get_feature_names()) print("="*100) # school_state vectorizer = CountVectorizer() vectorizer.fit(x_train['school_state'].values) # fit has to happen only on train data # we use the fitted CountVectorizer to convert the text to vector x_train_state_ohe = vectorizer.transform(x_train['school_state'].values) #x_cv_state_ohe = vectorizer.transform(x_cv['school_state'].values) x_test_state_ohe = vectorizer.transform(x_test['school_state'].values) print("After vectorizations") print(x_train_state_ohe.shape, y_train.shape) #print(x_cv_state_ohe.shape, y_cv.shape) print(x_test_state_ohe.shape, y_test.shape) print(vectorizer.get_feature_names()) print("="*100) project_grade_category= x_train['project_grade_category'].unique() vectorizer5 = CountVectorizer(vocabulary=list(project_grade_category), lowercase=False, binary=True) vectorizer5.fit(x_train['project_grade_category'].values) # fit has to happen only on train data # we use the fitted CountVectorizer to convert the text to vector x_train_grade_ohe = vectorizer5.transform(x_train['project_grade_category'].values) #x_cv_grade_ohe = vectorizer.transform(x_cv['project_grade_category'].values) x_test_grade_ohe = vectorizer5.transform(x_test['project_grade_category'].values) print("After vectorizations") print(x_train_grade_ohe.shape, y_train.shape) #print(x_cv_grade_ohe.shape, y_cv.shape) print(x_test_grade_ohe.shape, y_test.shape) print(vectorizer5.get_feature_names()) print("="*100) # Standarized the numerical features: Price from sklearn.preprocessing import StandardScaler price_scalar = StandardScaler() price_scalar.fit(x_train['price'].values.reshape(-1,1)) # finding the mean and standard deviation of this data x_train_price_std = price_scalar.transform(x_train['price'].values.reshape(-1,1)) #x_cv_price_std = price_scalar.transform(x_cv['price'].values.reshape(-1,1)) x_test_price_std = price_scalar.transform(x_test['price'].values.reshape(-1,1)) print("After vectorizations") print(x_train_price_std.shape, y_train.shape) #print(x_cv_price_std.shape, y_cv.shape) print(x_test_price_std.shape, y_test.shape) print("="*100) print(f"Mean : {price_scalar.mean_[0]}, Standard deviation : {np.sqrt(price_scalar.var_[0])}") x_train_price_std # Standarized the numerical features: teacher_previously from sklearn.preprocessing import StandardScaler teacher_previously_scalar = StandardScaler() teacher_previously_scalar.fit(x_train['teacher_number_of_previously_posted_projects'].values.reshape(-1,1)) # finding the mean and standard deviation of this data x_train_teacher_previously_std = teacher_previously_scalar.transform(x_train['teacher_number_of_previously_posted_projects'].values.reshape(-1,1)) #x_cv_teacher_previously_std = teacher_previously_scalar.transform(x_cv['teacher_number_of_previously_posted_projects'].values.reshape(-1,1)) x_test_teacher_previously_std = teacher_previously_scalar.transform(x_test['teacher_number_of_previously_posted_projects'].values.reshape(-1,1)) print("After vectorizations") print(x_train_teacher_previously_std.shape, y_train.shape) #print(x_cv_teacher_previously_std.shape, y_cv.shape) print(x_test_teacher_previously_std.shape, y_test.shape) print("="*100) print(f"Mean : {teacher_previously_scalar.mean_[0]}, Standard deviation : {np.sqrt(teacher_previously_scalar.var_[0])}") # Standarized the numerical features:quantity from sklearn.preprocessing import StandardScaler quantity_scalar = StandardScaler() quantity_scalar.fit(x_train['quantity'].values.reshape(-1,1)) # finding the mean and standard deviation of this data x_train_quantity_std = quantity_scalar.transform(x_train['quantity'].values.reshape(-1,1)) #x_cv_teacher_previously_std = teacher_previously_scalar.transform(x_cv['teacher_number_of_previously_posted_projects'].values.reshape(-1,1)) x_test_quantity_std = quantity_scalar.transform(x_test['quantity'].values.reshape(-1,1)) print("After vectorizations") print(x_train_quantity_std.shape, y_train.shape) #print(x_cv_teacher_previously_std.shape, y_cv.shape) print(x_test_quantity_std.shape, y_test.shape) print("="*100) print(f"Mean : {quantity_scalar.mean_[0]}, Standard deviation : {np.sqrt(quantity_scalar.var_[0])}") # CONCATINATE all features # merge two sparse matrices: https://stackoverflow.com/a/19710648/4084039 from scipy.sparse import hstack X_train = hstack((x_train_essay_bow,x_train_titles_bow,x_train_clean_cat_ohe,x_train_clean_subcat_ohe, x_train_state_ohe, x_train_teacher_pre, x_train_grade_ohe, x_train_price_std,x_train_teacher_previously_std)).tocsr() #X_cv = hstack((x_cv_essay_bow,x_cv_titles_bow,x_cv_clean_cat_ohe,x_cv_clean_subcat_ohe, x_cv_state_ohe, x_cv_teacher_pre, x_cv_grade_ohe, x_cv_price_std,x_cv_teacher_previously_std)).tocsr() X_test = hstack((x_test_essay_bow,x_test_titles_bow,x_test_clean_cat_ohe,x_test_clean_subcat_ohe, x_test_state_ohe, x_test_teacher_pre, x_test_grade_ohe, x_test_price_std,x_test_teacher_previously_std)).tocsr() print("Final Data matrix") print(X_train.shape, y_train.shape) #print(X_cv.shape, y_cv.shape) print(X_test.shape, y_test.shape) print("="*100) type(X_train) ###Output _____no_output_____ ###Markdown SET : 1 [BOW} ###Code from sklearn.model_selection import GridSearchCV from sklearn.linear_model import SGDClassifier clf_param_grid = { 'alpha' : [10**-x for x in range(-4,5)], 'penalty' : ['l1','l2'] } SGD1 = SGDClassifier(class_weight='balanced') estimator = GridSearchCV(SGD1, param_grid=clf_param_grid ,cv=10, verbose=1, scoring="roc_auc",n_jobs=-1) estimator.fit(X_train,y_train) print(estimator.best_params_) import warnings warnings.filterwarnings("ignore") b1=estimator.best_params_["alpha"] p1=estimator.best_params_["penalty"] import matplotlib.pyplot as plt import math train_auc1= estimator.cv_results_['mean_train_score'][estimator.cv_results_['param_penalty']==p1] train_auc_std1= estimator.cv_results_['std_train_score'][estimator.cv_results_['param_penalty']==p1] cv_auc1 = estimator.cv_results_['mean_test_score'][estimator.cv_results_['param_penalty']==p1] cv_auc_std1= estimator.cv_results_['std_test_score'][estimator.cv_results_['param_penalty']==p1] ax=plt.subplot() plt.plot(clf_param_grid['alpha'], train_auc1, label='Train AUC') # this code is copied from here: https://stackoverflow.com/a/48803361/4084039 plt.gca().fill_between(clf_param_grid['alpha'],train_auc1 - train_auc_std1,train_auc1 + train_auc_std1,alpha=0.2,color='darkblue') # create a shaded area between [mean - std, mean + std] plt.plot(clf_param_grid['alpha'], cv_auc1, label='CV AUC') # this code is copied from here: https://stackoverflow.com/a/48803361/4084039 plt.gca().fill_between(clf_param_grid['alpha'],cv_auc1 - cv_auc_std1,cv_auc1 + cv_auc_std1,alpha=0.2,color='darkorange') plt.scatter(clf_param_grid['alpha'], train_auc1, label='Train AUC points') plt.scatter(clf_param_grid['alpha'], cv_auc1, label='CV AUC points') plt.xscale('log') plt.axis('tight') plt.legend() plt.xlabel("alpha: hyperparameter") plt.ylabel("AUC") plt.title("ERROR PLOTS") plt.grid() plt.show() model_new1=SGDClassifier(penalty=p1, alpha= b1,class_weight='balanced',random_state=1) model_new1.fit(X_train,y_train) import numpy as np import math # custom function def sigmoid(x): return 1 / (1 + math.exp(-x)) # define vectorized sigmoid sigmoid_v = np.vectorize(sigmoid) # test scores = np.array([ -0.54761371, 17.04850603, 4.86054302]) print (sigmoid_v(scores)) from sklearn.metrics import roc_curve from sklearn.metrics import auc import matplotlib.pyplot as plt score_roc_train = model_new1.decision_function(X_train) fpr_train, tpr_train, threshold_train = roc_curve(y_train, sigmoid_v(score_roc_train)) roc_auc_train = auc(fpr_train, tpr_train) score_roc_test = model_new1.decision_function(X_test) fpr_test, tpr_test, threshold_test = roc_curve(y_test,sigmoid_v( score_roc_test)) roc_auc_test = auc(fpr_test, tpr_test) plt.plot(fpr_train, tpr_train, label = "Train_AUC"+str(auc(fpr_train, tpr_train))) plt.plot(fpr_test, tpr_test, label = "Test_AUC"+str(auc(fpr_test, tpr_test))) plt.legend(loc = 'lower right') plt.plot([0, 1], [0, 1],'r--') plt.xlim([0, 1]) plt.ylim([0, 1]) plt.ylabel('True Positive Rate') plt.xlabel('False Positive Rate') plt.title('ROC Curve of SVM ') plt.show() y_train_pred = model_new1.predict(X_train) y_test_pred = model_new1.predict(X_test) # we are defining are own function for use probabilities to plot confusion matrix # we have to plot confusion matrix at least fpr and high tpr values def predict(proba,threshold,fpr,tpr): t = threshold[np.argmax(tpr*(1-fpr))] # (tpr*(1-fpr)) will be maximum if your fpr is very low and tpr is very high print("the maximum value of tpr*(1-fpr)", max(tpr*(1-fpr)), "for threshold", np.round(t,3)) predictions = [] for i in proba: if i>=t: predictions.append(1) else: predictions.append(0) return predictions from sklearn.metrics import confusion_matrix import seaborn as sns ax = plt.subplot() print("Train confusion matrix") cnn_train = confusion_matrix(y_train, predict(y_train_pred, threshold_train, fpr_train, tpr_train)) sns.heatmap(cnn_train,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') ax = plt.subplot() print("Test confusion matrix") cnn_test = confusion_matrix(y_test, predict(y_test_pred, threshold_test, fpr_test, tpr_test)) sns.heatmap(cnn_test,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import classification_report print("_" * 101) print("Classification Report: \n") print(classification_report(y_test,y_test_pred)) print("_" * 101) ###Output _____________________________________________________________________________________________________ Classification Report: precision recall f1-score support 0 0.30 0.53 0.39 2303 1 0.90 0.78 0.83 12697 micro avg 0.74 0.74 0.74 15000 macro avg 0.60 0.65 0.61 15000 weighted avg 0.81 0.74 0.77 15000 _____________________________________________________________________________________________________ ###Markdown SET : 2 ()tf-idf TFIDF VECTORIZER ###Code from sklearn.feature_extraction.text import TfidfVectorizer vectorizer8 = TfidfVectorizer(min_df=10) preprocessed_essays_xtr_tfidf = vectorizer8.fit_transform(x_train['cleaned_essays']) print("Shape of matrix after one hot encodig ",preprocessed_essays_xtr_tfidf.shape) preprocessed_essays_xtest_tfidf = vectorizer8.transform(x_test['cleaned_essays']) print("Shape of matrix after one hot encodig ",preprocessed_essays_xtest_tfidf.shape) vectorizer9 = TfidfVectorizer(min_df=10) preprocessed_title_xtr_tfidf = vectorizer9.fit_transform(x_train['cleaned_title_text']) print("Shape of matrix after one hot encodig ",preprocessed_title_xtr_tfidf.shape) preprocessed_title_xtest_tfidf = vectorizer9.transform(x_test['cleaned_title_text']) print("Shape of matrix after one hot encodig ",preprocessed_title_xtest_tfidf.shape) X_train_tfidf=hstack((preprocessed_essays_xtr_tfidf,preprocessed_title_xtr_tfidf,x_train_clean_cat_ohe,x_train_clean_subcat_ohe,x_train_state_ohe,x_train_teacher_pre,x_train_grade_ohe,x_train_price_std,x_train_teacher_previously_std ,x_train_quantity_std )) #X_cv_tfidf=hstack((preprocessed_essays_xcv_tfidf,preprocessed_title_xcv_tfidf,x_cv_clean_cat_ohe,x_cv_clean_subcat_ohe, x_cv_state_ohe, x_cv_teacher_pre, x_cv_grade_ohe, x_cv_price_std,x_cv_teacher_previously_std)) X_test_tfidf=hstack((preprocessed_essays_xtest_tfidf,preprocessed_title_xtest_tfidf,x_test_clean_cat_ohe,x_test_clean_subcat_ohe, x_test_state_ohe, x_test_teacher_pre, x_test_grade_ohe, x_test_price_std,x_test_teacher_previously_std ,x_test_quantity_std )) from sklearn.model_selection import GridSearchCV from sklearn.linear_model import SGDClassifier clf_param_grid = { 'alpha' : [10**-x for x in range(-6,5)], 'penalty' : ['l1','l2'] } SGD2 = SGDClassifier(class_weight='balanced') estimator2 = GridSearchCV(SGD2, param_grid=clf_param_grid ,cv=10, verbose=2, scoring="roc_auc",n_jobs=-1) estimator2.fit(X_train_tfidf,y_train) print(estimator2.best_params_) b2=estimator2.best_params_["alpha"] p2=estimator2.best_params_["penalty"] train_auc2= estimator2.cv_results_['mean_train_score'][estimator2.cv_results_['param_penalty']==p2] train_auc_std2= estimator2.cv_results_['std_train_score'][estimator2.cv_results_['param_penalty']==p2] cv_auc2 = estimator2.cv_results_['mean_test_score'][estimator2.cv_results_['param_penalty']==p2] cv_auc_std2= estimator2.cv_results_['std_test_score'][estimator2.cv_results_['param_penalty']==p2] ax=plt.subplot() plt.plot(clf_param_grid['alpha'], train_auc2, label='Train AUC') # this code is copied from here: https://stackoverflow.com/a/48803362/4084039 plt.gca().fill_between(clf_param_grid['alpha'],train_auc2 - train_auc_std2,train_auc2 + train_auc_std2,alpha=0.2,color='darkblue') # create a shaded area between [mean - std, mean + std] plt.plot(clf_param_grid['alpha'], cv_auc2, label='CV AUC') # this code is copied from here: https://stackoverflow.com/a/48803362/4084039 plt.gca().fill_between(clf_param_grid['alpha'],cv_auc2 - cv_auc_std2,cv_auc2 + cv_auc_std2,alpha=0.2,color='darkorange') plt.scatter(clf_param_grid['alpha'], train_auc2, label='Train AUC points') plt.scatter(clf_param_grid['alpha'], cv_auc2, label='CV AUC points') plt.xscale('log') plt.axis('tight') plt.legend() plt.xlabel("alpha: hyperparameter") plt.ylabel("AUC") plt.title("ERROR PLOTS") plt.grid() plt.show() model_new2=SGDClassifier( penalty=p2, alpha= b2,class_weight='balanced') model_new2.fit(X_train_tfidf,y_train) score_roc_train = model_new2.decision_function(X_train_tfidf) fpr_train, tpr_train, threshold_train = roc_curve(y_train, sigmoid_v(score_roc_train)) roc_auc_train = auc(fpr_train, tpr_train) score_roc_test = model_new2.decision_function(X_test_tfidf) fpr_test, tpr_test, threshold_test = roc_curve(y_test,sigmoid_v (score_roc_test)) roc_auc_test = auc(fpr_test, tpr_test) plt.plot(fpr_train, tpr_train, label = "Train_AUC"+str(auc(fpr_train, tpr_train))) plt.plot(fpr_test, tpr_test, label = "Test_AUC"+str(auc(fpr_test, tpr_test))) plt.legend(loc = 'lower right') plt.plot([0, 1], [0, 1],'r--') plt.xlim([0, 1]) plt.ylim([0, 1]) plt.ylabel('True Positive Rate') plt.xlabel('False Positive Rate') plt.title('ROC Curve of SVM ') plt.show() y_train_pred = model_new2.predict(X_train_tfidf) y_test_pred = model_new2.predict(X_test_tfidf) from sklearn.metrics import confusion_matrix ax = plt.subplot() print("Train confusion matrix") cnn_train = confusion_matrix(y_train, predict(y_train_pred, threshold_train, fpr_train, tpr_train)) sns.heatmap(cnn_train,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import confusion_matrix ax = plt.subplot() print("test confusion matrix") cnn_test = confusion_matrix(y_test, predict(y_test_pred, threshold_test, fpr_test, tpr_test)) sns.heatmap(cnn_test,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import classification_report print("_" * 101) print("Classification Report: \n") print(classification_report(y_test,y_test_pred)) print("_" * 101) ###Output _____________________________________________________________________________________________________ Classification Report: precision recall f1-score support 0 0.24 0.66 0.35 2303 1 0.91 0.63 0.74 12697 micro avg 0.63 0.63 0.63 15000 macro avg 0.58 0.64 0.55 15000 weighted avg 0.81 0.63 0.68 15000 _____________________________________________________________________________________________________ ###Markdown SET 3 [AVG-W2V] ###Code list_preprocessed_essays_xtr = [] for e in x_train['cleaned_essays'].values: list_preprocessed_essays_xtr.append(e.split()) from gensim.models import Word2Vec from gensim.models import KeyedVectors preprocessed_essays_xtr_w2v=Word2Vec(list_preprocessed_essays_xtr,min_count=10,size=100,workers =12 ) # average Word2Vec # compute average word2vec for each review. preprocessed_essays_xtr_avg_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_train['cleaned_essays']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length cnt_words =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if word in preprocessed_essays_xtr_w2v.wv.vocab: vector += preprocessed_essays_xtr_w2v[word] cnt_words += 1 if cnt_words != 0: vector /= cnt_words preprocessed_essays_xtr_avg_w2v_vectors.append(vector) print(len(preprocessed_essays_xtr_avg_w2v_vectors)) print(len(preprocessed_essays_xtr_avg_w2v_vectors[0])) preprocessed_essays_xtest_avg_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_test['cleaned_essays']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length cnt_words =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if word in preprocessed_essays_xtr_w2v.wv.vocab: vector += preprocessed_essays_xtr_w2v[word] cnt_words += 1 if cnt_words != 0: vector /= cnt_words preprocessed_essays_xtest_avg_w2v_vectors.append(vector) print(len(preprocessed_essays_xtest_avg_w2v_vectors)) print(len(preprocessed_essays_xtest_avg_w2v_vectors[0])) list_preprocessed_title_xtr = [] for e in x_train['cleaned_title_text'].values: list_preprocessed_title_xtr.append(e.split()) preprocessed_title_xtr_w2v=Word2Vec(list_preprocessed_title_xtr,min_count=10,size=100,workers = 8) preprocessed_title_xtr_avg_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_train['cleaned_title_text']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length cnt_words =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if word in preprocessed_title_xtr_w2v.wv.vocab: vector += preprocessed_title_xtr_w2v[word] cnt_words += 1 if cnt_words != 0: vector /= cnt_words preprocessed_title_xtr_avg_w2v_vectors.append(vector) print(len(preprocessed_title_xtr_avg_w2v_vectors)) print(len(preprocessed_title_xtr_avg_w2v_vectors[0])) preprocessed_title_xtest_avg_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_test['cleaned_title_text']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length cnt_words =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if word in preprocessed_title_xtr_w2v.wv.vocab: vector += preprocessed_title_xtr_w2v[word] cnt_words += 1 if cnt_words != 0: vector /= cnt_words preprocessed_title_xtest_avg_w2v_vectors.append(vector) print(len(preprocessed_title_xtest_avg_w2v_vectors)) print(len(preprocessed_title_xtest_avg_w2v_vectors[0])) from scipy.sparse import hstack X_train_w2v=hstack((preprocessed_essays_xtr_avg_w2v_vectors,preprocessed_title_xtr_avg_w2v_vectors,x_train_clean_cat_ohe,x_train_clean_subcat_ohe,x_train_state_ohe,x_train_teacher_pre,x_train_grade_ohe,x_train_price_std,x_train_teacher_previously_std ,x_train_quantity_std)) #X_cv_tfidf=hstack((preprocessed_essays_xcv_tfidf,preprocessed_title_xcv_tfidf,x_cv_clean_cat_ohe,x_cv_clean_subcat_ohe, x_cv_state_ohe, x_cv_teacher_pre, x_cv_grade_ohe, x_cv_price_std,x_cv_teacher_previously_std)) X_test_w2v=hstack((preprocessed_essays_xtest_avg_w2v_vectors,preprocessed_essays_xtest_avg_w2v_vectors,x_test_clean_cat_ohe,x_test_clean_subcat_ohe, x_test_state_ohe, x_test_teacher_pre, x_test_grade_ohe, x_test_price_std,x_test_teacher_previously_std ,x_test_quantity_std)) print(X_train_w2v.shape) print(X_test_w2v.shape) from sklearn.model_selection import RandomizedSearchCV from sklearn.linear_model import SGDClassifier clf_param_grid = { 'alpha' : [10**-x for x in range(-6,5)], 'penalty' : ['l1','l2'] } SGD3 = SGDClassifier(class_weight='balanced') estimator3 = RandomizedSearchCV(SGD3, param_distributions=clf_param_grid ,cv=10, verbose=2,scoring="roc_auc",n_jobs=6) estimator3.fit(X_train_w2v,y_train) print(estimator3.best_params_) b3=estimator3.best_params_["alpha"] p3=estimator3.best_params_["penalty"] train_auc3= estimator3.cv_results_['mean_train_score'][estimator3.cv_results_['param_penalty']==p3] train_auc_std3= estimator3.cv_results_['std_train_score'][estimator3.cv_results_['param_penalty']==p3] cv_auc3 = estimator3.cv_results_['mean_test_score'][estimator3.cv_results_['param_penalty']==p3] cv_auc_std3= estimator3.cv_results_['std_test_score'][estimator3.cv_results_['param_penalty']==p3] plt.plot(clf_param_grid['alpha'][:4], train_auc3, label='Train AUC') # this code is copied from here: https://stackoverflow.com/a/48803363/4084039 #plt.gca().fill_between(clf_param_grid['alpha'][:4],train_auc3 - train_auc_std3,train_auc3 + train_auc_std3,alpha=0.3,color='darkblue') # create a shaded area between [mean - std, mean + std] plt.plot(clf_param_grid['alpha'][:4], cv_auc3, label='CV AUC') # this code is copied from here: https://stackoverflow.com/a/48803363/4084039 #plt.gca().fill_between(clf_param_grid['alpha'][:4],cv_auc3 - cv_auc_std3,cv_auc3 + cv_auc_std3,alpha=0.3,color='darkorange') plt.scatter(clf_param_grid['alpha'][:4], train_auc3, label='Train AUC points') plt.scatter(clf_param_grid['alpha'][:4], cv_auc3, label='CV AUC points') plt.xscale('log') plt.legend() plt.xlabel("alpha: hyperparameter") plt.ylabel("AUC") plt.title("ERROR PLOTS") plt.grid() plt.show() model_new3=SGDClassifier( penalty=p3, alpha= b3,class_weight='balanced') model_new3.fit(X_train_w2v,y_train) score_roc_train = model_new3.decision_function(X_train_w2v) fpr_train, tpr_train, threshold_train = roc_curve(y_train, sigmoid_v(score_roc_train)) roc_auc_train = auc(fpr_train, tpr_train) score_roc_test = model_new3.decision_function(X_test_w2v) fpr_test, tpr_test, threshold_test = roc_curve(y_test, sigmoid_v(score_roc_test)) roc_auc_test = auc(fpr_test, tpr_test) plt.plot(fpr_train, tpr_train, label = "Train_AUC"+str(auc(fpr_train, tpr_train))) plt.plot(fpr_test, tpr_test, label = "Test_AUC"+str(auc(fpr_test, tpr_test))) plt.legend(loc = 'lower right') plt.plot([0, 1], [0, 1],'r--') plt.xlim([0, 1]) plt.ylim([0, 1]) plt.ylabel('True Positive Rate') plt.xlabel('False Positive Rate') plt.title('ROC Curve of SVM ') plt.show() y_train_pred = model_new3.predict(X_train_w2v) y_test_pred = model_new3.predict(X_test_w2v) from sklearn.metrics import confusion_matrix ax = plt.subplot() print("Train confusion matrix") cnn_train = confusion_matrix(y_train, predict(y_train_pred, threshold_train, fpr_train, tpr_train)) sns.heatmap(cnn_train,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') ax = plt.subplot() print("test confusion matrix") cnn_test = confusion_matrix(y_test, predict(y_test_pred, threshold_test, fpr_test, tpr_test)) sns.heatmap(cnn_test,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import classification_report print("_" * 101) print("Classification Report: \n") print(classification_report(y_test,y_test_pred)) print("_" * 101) ###Output _____________________________________________________________________________________________________ Classification Report: precision recall f1-score support 0 0.29 0.40 0.33 2303 1 0.88 0.82 0.85 12697 micro avg 0.76 0.76 0.76 15000 macro avg 0.58 0.61 0.59 15000 weighted avg 0.79 0.76 0.77 15000 _____________________________________________________________________________________________________ ###Markdown SET : 4 [TFIDF-W2V] ###Code from sklearn.feature_extraction.text import TfidfVectorizer tfidf_model1 = TfidfVectorizer() tfidf_model1.fit(x_train['cleaned_essays']) # we are converting a dictionary with word as a key, and the idf as a value dictionary = dict(zip(tfidf_model1.get_feature_names(), list(tfidf_model1.idf_))) tfidf_words = set(tfidf_model1.get_feature_names()) # average Word2Vec # compute average word2vec for each review. preprocessed_essays_xtr_tfidf_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_train['cleaned_essays']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length tf_idf_weight =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if (word in list(preprocessed_essays_xtr_w2v.wv.vocab)) and (word in tfidf_words): vec = preprocessed_essays_xtr_w2v[word] # getting the vector for each word # here we are multiplying idf value(dictionary[word]) and the tf value((sentence.count(word)/len(sentence.split()))) tf_idf = dictionary[word]*(sentence.count(word)/len(sentence.split())) # getting the tfidf value for each word vector += (vec * tf_idf) # calculating tfidf weighted w2v tf_idf_weight += tf_idf if tf_idf_weight != 0: vector /= tf_idf_weight preprocessed_essays_xtr_tfidf_w2v_vectors.append(vector) print(len(preprocessed_essays_xtr_tfidf_w2v_vectors)) print(len(preprocessed_essays_xtr_tfidf_w2v_vectors[0])) preprocessed_essays_xtest_tfidf_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_test['cleaned_essays']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length tf_idf_weight =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if (word in list(preprocessed_essays_xtr_w2v.wv.vocab)) and (word in tfidf_words): vec = preprocessed_essays_xtr_w2v[word] # getting the vector for each word # here we are multiplying idf value(dictionary[word]) and the tf value((sentence.count(word)/len(sentence.split()))) tf_idf = dictionary[word]*(sentence.count(word)/len(sentence.split())) # getting the tfidf value for each word vector += (vec * tf_idf) # calculating tfidf weighted w2v tf_idf_weight += tf_idf if tf_idf_weight != 0: vector /= tf_idf_weight preprocessed_essays_xtest_tfidf_w2v_vectors.append(vector) print(len(preprocessed_essays_xtest_tfidf_w2v_vectors)) print(len(preprocessed_essays_xtest_tfidf_w2v_vectors[0])) # Similarly you can vectorize for title also tfidf_model2 = TfidfVectorizer() tfidf_model2.fit(x_train['cleaned_title_text']) # we are converting a dictionary with word as a key, and the idf as a value dictionary = dict(zip(tfidf_model2.get_feature_names(), list(tfidf_model1.idf_))) tfidf_words = set(tfidf_model2.get_feature_names()) preprocessed_title_xtr_tfidf_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_train['cleaned_title_text']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length tf_idf_weight =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if (word in list(preprocessed_title_xtr_w2v.wv.vocab)) and (word in tfidf_words): vec = preprocessed_title_xtr_w2v[word] # getting the vector for each word # here we are multiplying idf value(dictionary[word]) and the tf value((sentence.count(word)/len(sentence.split()))) tf_idf = dictionary[word]*(sentence.count(word)/len(sentence.split())) # getting the tfidf value for each word vector += (vec * tf_idf) # calculating tfidf weighted w2v tf_idf_weight += tf_idf if tf_idf_weight != 0: vector /= tf_idf_weight preprocessed_title_xtr_tfidf_w2v_vectors.append(vector) print(len(preprocessed_title_xtr_tfidf_w2v_vectors)) print(len(preprocessed_title_xtr_tfidf_w2v_vectors[0])) preprocessed_title_xtest_tfidf_w2v_vectors = []; # the avg-w2v for each sentence/review is stored in this list for sentence in tqdm(x_test['cleaned_title_text']): # for each review/sentence vector = np.zeros(100) # as word vectors are of zero length tf_idf_weight =0; # num of words with a valid vector in the sentence/review for word in sentence.split(): # for each word in a review/sentence if (word in list(preprocessed_title_xtr_w2v.wv.vocab)) and (word in tfidf_words): vec = preprocessed_title_xtr_w2v[word] # getting the vector for each word # here we are multiplying idf value(dictionary[word]) and the tf value((sentence.count(word)/len(sentence.split()))) tf_idf = dictionary[word]*(sentence.count(word)/len(sentence.split())) # getting the tfidf value for each word vector += (vec * tf_idf) # calculating tfidf weighted w2v tf_idf_weight += tf_idf if tf_idf_weight != 0: vector /= tf_idf_weight preprocessed_title_xtest_tfidf_w2v_vectors.append(vector) print(len(preprocessed_title_xtest_tfidf_w2v_vectors)) print(len(preprocessed_title_xtest_tfidf_w2v_vectors[0])) X_train_tfidf_w2v=hstack((preprocessed_essays_xtr_tfidf_w2v_vectors,preprocessed_title_xtr_tfidf_w2v_vectors,x_train_clean_cat_ohe,x_train_clean_subcat_ohe,x_train_state_ohe,x_train_teacher_pre,x_train_grade_ohe,x_train_price_std,x_train_teacher_previously_std ,x_train_quantity_std )) #X_cv_tfidf=hstack((preprocessed_essays_xcv_tfidf,preprocessed_title_xcv_tfidf,x_cv_clean_cat_ohe,x_cv_clean_subcat_ohe, x_cv_state_ohe, x_cv_teacher_pre, x_cv_grade_ohe, x_cv_price_std,x_cv_teacher_previously_std)) X_test_tfidf_w2v=hstack((preprocessed_essays_xtest_tfidf_w2v_vectors,preprocessed_essays_xtest_tfidf_w2v_vectors,x_test_clean_cat_ohe,x_test_clean_subcat_ohe, x_test_state_ohe, x_test_teacher_pre, x_test_grade_ohe, x_test_price_std,x_test_teacher_previously_std ,x_test_quantity_std)) print(X_train_tfidf_w2v.shape) print(X_test_tfidf_w2v.shape) from sklearn.model_selection import RandomizedSearchCV from sklearn.linear_model import SGDClassifier clf_param_grid = { 'alpha' : [10**-x for x in range(-6,6)], 'penalty' : ['l1','l2'] } SGD4 = SGDClassifier(class_weight='balanced') estimator4 = RandomizedSearchCV(SGD4, param_distributions=clf_param_grid ,cv=10, verbose=2,scoring="roc_auc",n_jobs=4) estimator4.fit(X_train_tfidf_w2v,y_train) print(estimator4.best_params_) b4=estimator4.best_params_["alpha"] p4=estimator4.best_params_["penalty"] train_auc4= estimator4.cv_results_['mean_train_score'][estimator4.cv_results_['param_penalty']==p4] train_auc_std4= estimator4.cv_results_['std_train_score'][estimator4.cv_results_['param_penalty']==p4] cv_auc4 = estimator4.cv_results_['mean_test_score'][estimator4.cv_results_['param_penalty']==p4] cv_auc_std4= estimator4.cv_results_['std_test_score'][estimator4.cv_results_['param_penalty']==p4] ax=plt.subplot() plt.plot(clf_param_grid['alpha'][:6], train_auc4, label='Train AUC') # this code is copied from here: https://stackoverflow.com/a/48804464/4084049 #plt.gca().fill_between(clf_param_grid['alpha'][:6],train_auc4 - train_auc_std4,train_auc4 + train_auc_std4,alpha=0.4,color='darkblue') # create a shaded area between [mean - std, mean + std] plt.plot(clf_param_grid['alpha'][:6], cv_auc4, label='CV AUC') # this code is copied from here: https://stackoverflow.com/a/48804464/4084049 #plt.gca().fill_between(clf_param_grid['alpha'][:6],cv_auc4 - cv_auc_std4,cv_auc4 + cv_auc_std4,alpha=0.4,color='darkorange') plt.scatter(clf_param_grid['alpha'][:6], train_auc4, label='Train AUC points') plt.scatter(clf_param_grid['alpha'][:6], cv_auc4, label='CV AUC points') plt.axis([10**-1,10**5,0.675,0.710]) plt.xscale('log') plt.axis('tight') plt.legend() plt.xlabel("alpha: hyperparameter") plt.ylabel("AUC") plt.title("ERROR PLOTS") plt.grid() plt.show() model_new4 = SGDClassifier( penalty=p4, alpha=b4,class_weight='balanced') model_new4.fit(X_train_tfidf_w2v,y_train) score_roc_train = model_new4.decision_function(X_train_tfidf_w2v) fpr_train, tpr_train, threshold_train = roc_curve(y_train, sigmoid_v(score_roc_train)) roc_auc_train = auc(fpr_train, tpr_train) score_roc_test = model_new4.decision_function(X_test_tfidf_w2v) fpr_test, tpr_test, threshold_test = roc_curve(y_test, sigmoid_v(score_roc_test)) roc_auc_test = auc(fpr_test, tpr_test) plt.plot(fpr_train, tpr_train, label = "Train_AUC"+str(auc(fpr_train, tpr_train))) plt.plot(fpr_test, tpr_test, label = "Test_AUC"+str(auc(fpr_test, tpr_test))) plt.legend(loc = 'lower right') plt.plot([0, 1], [0, 1],'r--') plt.xlim([0, 1]) plt.ylim([0, 1]) plt.ylabel('True Positive Rate') plt.xlabel('False Positive Rate') plt.title('ROC Curve of KNN ') plt.show() y_train_pred = model_new4.predict(X_train_tfidf_w2v) y_test_pred = model_new4.predict(X_test_tfidf_w2v) from sklearn.metrics import confusion_matrix ax = plt.subplot() print("Train confusion matrix") cnn_train = confusion_matrix(y_train, predict(y_train_pred, threshold_train, fpr_train, tpr_train)) sns.heatmap(cnn_train,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import confusion_matrix ax = plt.subplot() print("test confusion matrix") cnn_test = confusion_matrix(y_test, predict(y_test_pred, threshold_test, fpr_test, tpr_test)) sns.heatmap(cnn_test,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import classification_report print("_" * 101) print("Classification Report: \n") print(classification_report(y_test,y_test_pred)) print("_" * 101) ###Output _____________________________________________________________________________________________________ Classification Report: precision recall f1-score support 0 0.24 0.71 0.36 2303 1 0.92 0.60 0.73 12697 micro avg 0.62 0.62 0.62 15000 macro avg 0.58 0.66 0.54 15000 weighted avg 0.82 0.62 0.67 15000 _____________________________________________________________________________________________________ ###Markdown SET : 5 [Truncated SVD] ###Code from sklearn.feature_extraction.text import TfidfVectorizer vectorizer8 = TfidfVectorizer(min_df=10) preprocessed_essays_xtr_tfidf = vectorizer8.fit_transform(x_train['cleaned_essays']) print("Shape of matrix after one hot encodig ",preprocessed_essays_xtr_tfidf.shape) preprocessed_essays_xtest_tfidf = vectorizer8.transform(x_test['cleaned_essays']) print("Shape of matrix after one hot encodig ",preprocessed_essays_xtest_tfidf.shape) ###Output Shape of matrix after one hot encodig (35000, 10483) Shape of matrix after one hot encodig (15000, 10483) ###Markdown CHECK FOR VARIANCE EXPLAINED BY n_components and find best no. of component ###Code from sklearn.decomposition import TruncatedSVD svd = TruncatedSVD(n_components=6000, algorithm='randomized', n_iter=5, random_state=None, tol=0.0001) svd.fit(preprocessed_essays_xtr_tfidf) # List of explained variances tsvd_var_ratios = svd.explained_variance_ratio_ np.cumsum(tsvd_var_ratios) # Create a function for find best no. of components def select_n_components(var_ratio, goal_var: float): # Set initial variance explained so far total_variance = 0.0 # Set initial number of features n_components = 0 # For the explained variance of each feature: for explained_variance in var_ratio: total_variance += explained_variance n_components += 1 if total_variance >= goal_var: break return n_components ###Output _____no_output_____ ###Markdown Find total of 95% var explained ###Code n_components=select_n_components(tsvd_var_ratios, 0.95) n_components from sklearn.decomposition import TruncatedSVD svd_tr = TruncatedSVD(n_components=5722, algorithm='randomized', n_iter=5, random_state=None, tol=0.001) svd_train = svd_tr.fit_transform(preprocessed_essays_xtr_tfidf) svd_test = svd_tr.transform(preprocessed_essays_xtest_tfidf) from scipy.sparse import hstack X_train_s5=hstack((svd_train,x_train_clean_cat_ohe,x_train_clean_subcat_ohe,x_train_state_ohe,x_train_teacher_pre,x_train_grade_ohe,x_train_price_std,x_train_teacher_previously_std ,x_train_quantity_std )).tocsr() X_test_s5=hstack((svd_test,x_test_clean_cat_ohe,x_test_clean_subcat_ohe, x_test_state_ohe, x_test_teacher_pre, x_test_grade_ohe, x_test_price_std,x_test_teacher_previously_std ,x_test_quantity_std)).tocsr() from sklearn.model_selection import GridSearchCV from sklearn.linear_model import SGDClassifier clf_param_grid = { 'alpha' : [10**-x for x in range(-4,5)], 'penalty' : ['l1','l2'] } SGD5 = SGDClassifier(class_weight='balanced') estimator5 = GridSearchCV(SGD5, param_grid=clf_param_grid ,cv=5, verbose=21, scoring="roc_auc",n_jobs=3) estimator5.fit(X_train_s5,y_train) print(estimator5.best_params_) b5=estimator5.best_params_["alpha"] p5=estimator5.best_params_["penalty"] train_auc5= estimator5.cv_results_['mean_train_score'][estimator5.cv_results_['param_penalty']==p5] train_auc_std5= estimator5.cv_results_['std_train_score'][estimator5.cv_results_['param_penalty']==p5] cv_auc5 = estimator5.cv_results_['mean_test_score'][estimator5.cv_results_['param_penalty']==p5] cv_auc_std5= estimator5.cv_results_['std_test_score'][estimator5.cv_results_['param_penalty']==p5] ax=plt.subplot() plt.plot(clf_param_grid['alpha'][:9], train_auc5, label='Train AUC') # this code is copied from here: https://stackoverflow.com/a/58805565/5085059 #plt.gca().fill_between(clf_param_grid['alpha'][:9],train_auc5 - train_auc_std5,train_auc5 + train_auc_std5,alpha=0.5,color='darkblue') # create a shaded area between [mean - std, mean + std] plt.plot(clf_param_grid['alpha'][:9], cv_auc5, label='CV AUC') # this code is copied from here: https://stackoverflow.com/a/58805565/5085059 #plt.gca().fill_between(clf_param_grid['alpha'][:9],cv_auc5 - cv_auc_std5,cv_auc5 + cv_auc_std5,alpha=0.5,color='darkorange') plt.scatter(clf_param_grid['alpha'][:9], train_auc5, label='Train AUC points') plt.scatter(clf_param_grid['alpha'][:9], cv_auc5, label='CV AUC points') plt.axis([10**-2,10**5,0.675,0.710]) plt.xscale('log') plt.axis('tight') plt.legend() plt.xlabel("alpha: hyperparameter") plt.ylabel("AUC") plt.title("ERROR PLOTS") plt.grid() plt.show() model_new5=SGDClassifier( penalty=p5, alpha=b5,class_weight='balanced') model_new5.fit(X_train_s5,y_train) score_roc_train = model_new5.decision_function(X_train_s5) fpr_train, tpr_train, threshold_train = roc_curve(y_train, sigmoid_v(score_roc_train)) roc_auc_train = auc(fpr_train, tpr_train) score_roc_test = model_new5.decision_function(X_test_s5) fpr_test, tpr_test, threshold_test = roc_curve(y_test, sigmoid_v(score_roc_test)) roc_auc_test = auc(fpr_test, tpr_test) plt.plot(fpr_train, tpr_train, label = "Train_AUC"+str(auc(fpr_train, tpr_train))) plt.plot(fpr_test, tpr_test, label = "Test_AUC"+str(auc(fpr_test, tpr_test))) plt.legend(loc = 'lower right') plt.plot([0, 1], [0, 1],'r--') plt.xlim([0, 1]) plt.ylim([0, 1]) plt.ylabel('True Positive Rate') plt.xlabel('False Positive Rate') plt.title('ROC Curve of SVM ') plt.show() y_train_pred = model_new5.predict(X_train_s5) y_test_pred = model_new5.predict(X_test_s5) from sklearn.metrics import confusion_matrix ax = plt.subplot() print("Train confusion matrix") cnn_train = confusion_matrix(y_train, predict(y_train_pred, threshold_train, fpr_train, tpr_train)) sns.heatmap(cnn_train,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import confusion_matrix ax = plt.subplot() print("test confusion matrix") cnn_test = confusion_matrix(y_test, predict(y_test_pred, threshold_test, fpr_test, tpr_test)) sns.heatmap(cnn_test,annot = True,ax=ax,fmt='d') ax.set_xlabel('Predicted label') ax.set_ylabel('True label') ax.xaxis.set_ticklabels(['negative','positive']) ax.yaxis.set_ticklabels(['negative','positive']) plt.title('Confusion Matrix\n') from sklearn.metrics import classification_report print("_" * 101) print("Classification Report: \n") print(classification_report(y_test,y_test_pred)) print("_" * 101) from prettytable import PrettyTable pretty = PrettyTable() pretty.field_names = ['Vectorizer','Model','Hyperparameter_alpha','Hyperparameter_penalty','AUC'] pretty.add_row(['BOW','BRUTE',b1,p1,'0.71']) pretty.add_row(['TF-IDF','BRUTE',b2,p2,'0.69']) pretty.add_row(['AVG W2V','BRUTE',b3,p3,'0.68']) pretty.add_row(['TFIDF WEIGHTED','BRUTE',b4,p4,'0.69']) pretty.add_row(['TRUNCATED SVD','BRUTE',b5,p5,'0.69']) print(pretty) ###Output +----------------+-------+----------------------+------------------------+------+ | Vectorizer | Model | Hyperparameter_alpha | Hyperparameter_penalty | AUC | +----------------+-------+----------------------+------------------------+------+ | BOW | BRUTE | 0.1 | l2 | 0.71 | | TF-IDF | BRUTE | 0.001 | l2 | 0.69 | | AVG W2V | BRUTE | 0.001 | l2 | 0.68 | | TFIDF WEIGHTED | BRUTE | 0.01 | l2 | 0.69 | | TRUNCATED SVD | BRUTE | 0.0001 | l1 | 0.69 | +----------------+-------+----------------------+------------------------+------+
Google_stock_price_prediction_RNN.ipynb
###Markdown ###Code ! pip install kaggle ! mkdir ~/.kaggle ! cp kaggle.json ~/.kaggle/ ! chmod 600 ~/.kaggle/kaggle.json ! kaggle datasets download ptheru/googledta ! unzip googledta.zip import numpy as np # linear algebra import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv) import matplotlib.pyplot as plt from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from keras.layers import Dropout import os print(os.listdir("../content")) dataset_train = pd.read_csv("../content/trainset.csv") dataset_train trainset = dataset_train.iloc[:,1:2].values trainset from sklearn.preprocessing import MinMaxScaler sc = MinMaxScaler(feature_range = (0,1)) training_scaled = sc.fit_transform(trainset) training_scaled x_train = [] y_train = [] for i in range(60,1259): x_train.append(training_scaled[i-60:i, 0]) y_train.append(training_scaled[i,0]) x_train,y_train = np.array(x_train),np.array(y_train) x_train.shape x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1)) regressor = Sequential() regressor.add(LSTM(units = 50,return_sequences = True,input_shape = (x_train.shape[1],1))) regressor.add(Dropout(0.2)) regressor.add(LSTM(units = 50,return_sequences = True)) regressor.add(Dropout(0.2)) regressor.add(LSTM(units = 50,return_sequences = True)) regressor.add(Dropout(0.2)) regressor.add(LSTM(units = 50)) regressor.add(Dropout(0.2)) regressor.add(Dense(units = 1)) regressor.compile(optimizer = 'adam',loss = 'mean_squared_error') regressor.fit(x_train,y_train,epochs = 100, batch_size = 32) dataset_test =pd.read_csv("../content/testset.csv") dataset_test real_stock_price = dataset_test.iloc[:,1:2].values dataset_total = pd.concat((dataset_train['Open'],dataset_test['Open']),axis = 0) dataset_total inputs = dataset_total[len(dataset_total) - len(dataset_test)-60:].values inputs inputs = inputs.reshape(-1,1) inputs inputs = sc.transform(inputs) inputs.shape x_test = [] for i in range(60,185): x_test.append(inputs[i-60:i,0]) x_test = np.array(x_test) x_test.shape x_test = np.reshape(x_test, (x_test.shape[0],x_test.shape[1],1)) x_test.shape predicted_price = regressor.predict(x_test) predicted_price = sc.inverse_transform(predicted_price) predicted_price plt.plot(real_stock_price,color = 'red', label = 'Real Price') plt.plot(predicted_price, color = 'blue', label = 'Predicted Price') plt.title('Google Stock Price Prediction') plt.xlabel('Time') plt.ylabel('Google Stock Price') plt.legend() plt.show() ###Output _____no_output_____
course 2 - Improving Deep Neural Networks Hyperparameter tuning, Regularization and Optimization/programming assignments/.ipynb_checkpoints/Part3_Gradient+Checking-checkpoint.ipynb
###Markdown Gradient CheckingWelcome to the final assignment for this week! In this assignment you will learn to implement and use gradient checking. You are part of a team working to make mobile payments available globally, and are asked to build a deep learning model to detect fraud--whenever someone makes a payment, you want to see if the payment might be fraudulent, such as if the user's account has been taken over by a hacker. But backpropagation is quite challenging to implement, and sometimes has bugs. Because this is a mission-critical application, your company's CEO wants to be really certain that your implementation of backpropagation is correct. Your CEO says, "Give me a proof that your backpropagation is actually working!" To give this reassurance, you are going to use "gradient checking".Let's do it! ###Code # Packages import numpy as np from testCases import * from gc_utils import sigmoid, relu, dictionary_to_vector, vector_to_dictionary, gradients_to_vector ###Output _____no_output_____ ###Markdown 1) How does gradient checking work?Backpropagation computes the gradients $\frac{\partial J}{\partial \theta}$, where $\theta$ denotes the parameters of the model. $J$ is computed using forward propagation and your loss function.Because forward propagation is relatively easy to implement, you're confident you got that right, and so you're almost 100% sure that you're computing the cost $J$ correctly. Thus, you can use your code for computing $J$ to verify the code for computing $\frac{\partial J}{\partial \theta}$. Let's look back at the definition of a derivative (or gradient):$$ \frac{\partial J}{\partial \theta} = \lim_{\varepsilon \to 0} \frac{J(\theta + \varepsilon) - J(\theta - \varepsilon)}{2 \varepsilon} \tag{1}$$If you're not familiar with the "$\displaystyle \lim_{\varepsilon \to 0}$" notation, it's just a way of saying "when $\varepsilon$ is really really small."We know the following:- $\frac{\partial J}{\partial \theta}$ is what you want to make sure you're computing correctly. - You can compute $J(\theta + \varepsilon)$ and $J(\theta - \varepsilon)$ (in the case that $\theta$ is a real number), since you're confident your implementation for $J$ is correct. Lets use equation (1) and a small value for $\varepsilon$ to convince your CEO that your code for computing $\frac{\partial J}{\partial \theta}$ is correct! 2) 1-dimensional gradient checkingConsider a 1D linear function $J(\theta) = \theta x$. The model contains only a single real-valued parameter $\theta$, and takes $x$ as input.You will implement code to compute $J(.)$ and its derivative $\frac{\partial J}{\partial \theta}$. You will then use gradient checking to make sure your derivative computation for $J$ is correct. **Figure 1** : **1D linear model** The diagram above shows the key computation steps: First start with $x$, then evaluate the function $J(x)$ ("forward propagation"). Then compute the derivative $\frac{\partial J}{\partial \theta}$ ("backward propagation"). **Exercise**: implement "forward propagation" and "backward propagation" for this simple function. I.e., compute both $J(.)$ ("forward propagation") and its derivative with respect to $\theta$ ("backward propagation"), in two separate functions. ###Code # GRADED FUNCTION: forward_propagation def forward_propagation(x, theta): """ Implement the linear forward propagation (compute J) presented in Figure 1 (J(theta) = theta * x) Arguments: x -- a real-valued input theta -- our parameter, a real number as well Returns: J -- the value of function J, computed using the formula J(theta) = theta * x """ ### START CODE HERE ### (approx. 1 line) J = theta * x ### END CODE HERE ### return J x, theta = 2, 4 J = forward_propagation(x, theta) print ("J = " + str(J)) ###Output J = 8 ###Markdown **Expected Output**: ** J ** 8 **Exercise**: Now, implement the backward propagation step (derivative computation) of Figure 1. That is, compute the derivative of $J(\theta) = \theta x$ with respect to $\theta$. To save you from doing the calculus, you should get $dtheta = \frac { \partial J }{ \partial \theta} = x$. ###Code # GRADED FUNCTION: backward_propagation def backward_propagation(x, theta): """ Computes the derivative of J with respect to theta (see Figure 1). Arguments: x -- a real-valued input theta -- our parameter, a real number as well Returns: dtheta -- the gradient of the cost with respect to theta """ ### START CODE HERE ### (approx. 1 line) dtheta = x ### END CODE HERE ### return dtheta x, theta = 2, 4 dtheta = backward_propagation(x, theta) print ("dtheta = " + str(dtheta)) ###Output dtheta = 2 ###Markdown **Expected Output**: ** dtheta ** 2 **Exercise**: To show that the `backward_propagation()` function is correctly computing the gradient $\frac{\partial J}{\partial \theta}$, let's implement gradient checking.**Instructions**:- First compute "gradapprox" using the formula above (1) and a small value of $\varepsilon$. Here are the Steps to follow: 1. $\theta^{+} = \theta + \varepsilon$ 2. $\theta^{-} = \theta - \varepsilon$ 3. $J^{+} = J(\theta^{+})$ 4. $J^{-} = J(\theta^{-})$ 5. $gradapprox = \frac{J^{+} - J^{-}}{2 \varepsilon}$- Then compute the gradient using backward propagation, and store the result in a variable "grad"- Finally, compute the relative difference between "gradapprox" and the "grad" using the following formula:$$ difference = \frac {\mid\mid grad - gradapprox \mid\mid_2}{\mid\mid grad \mid\mid_2 + \mid\mid gradapprox \mid\mid_2} \tag{2}$$You will need 3 Steps to compute this formula: - 1'. compute the numerator using np.linalg.norm(...) - 2'. compute the denominator. You will need to call np.linalg.norm(...) twice. - 3'. divide them.- If this difference is small (say less than $10^{-7}$), you can be quite confident that you have computed your gradient correctly. Otherwise, there may be a mistake in the gradient computation. ###Code # GRADED FUNCTION: gradient_check def gradient_check(x, theta, epsilon = 1e-7): """ Implement the backward propagation presented in Figure 1. Arguments: x -- a real-valued input theta -- our parameter, a real number as well epsilon -- tiny shift to the input to compute approximated gradient with formula(1) Returns: difference -- difference (2) between the approximated gradient and the backward propagation gradient """ # Compute gradapprox using left side of formula (1). epsilon is small enough, you don't need to worry about the limit. ### START CODE HERE ### (approx. 5 lines) thetaplus = theta + epsilon # Step 1 thetaminus = theta - epsilon # Step 2 J_plus = thetaplus * x # Step 3 J_minus = thetaminus * x # Step 4 gradapprox = (J_plus - J_minus) / (2 * epsilon) # Step 5 ### END CODE HERE ### # Check if gradapprox is close enough to the output of backward_propagation() ### START CODE HERE ### (approx. 1 line) grad = x ### END CODE HERE ### ### START CODE HERE ### (approx. 1 line) numerator = np.linalg.norm(grad - gradapprox) # Step 1' denominator = np.linalg.norm(grad) + np.linalg.norm(gradapprox) # Step 2' difference = numerator / denominator # Step 3' ### END CODE HERE ### if difference < 1e-7: print ("The gradient is correct!") else: print ("The gradient is wrong!") return difference x, theta = 2, 4 difference = gradient_check(x, theta) print("difference = " + str(difference)) ###Output The gradient is correct! difference = 2.91933588329e-10 ###Markdown **Expected Output**:The gradient is correct! ** difference ** 2.9193358103083e-10 Congrats, the difference is smaller than the $10^{-7}$ threshold. So you can have high confidence that you've correctly computed the gradient in `backward_propagation()`. Now, in the more general case, your cost function $J$ has more than a single 1D input. When you are training a neural network, $\theta$ actually consists of multiple matrices $W^{[l]}$ and biases $b^{[l]}$! It is important to know how to do a gradient check with higher-dimensional inputs. Let's do it! 3) N-dimensional gradient checking The following figure describes the forward and backward propagation of your fraud detection model. **Figure 2** : **deep neural network***LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID*Let's look at your implementations for forward propagation and backward propagation. ###Code def forward_propagation_n(X, Y, parameters): """ Implements the forward propagation (and computes the cost) presented in Figure 3. Arguments: X -- training set for m examples Y -- labels for m examples parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3": W1 -- weight matrix of shape (5, 4) b1 -- bias vector of shape (5, 1) W2 -- weight matrix of shape (3, 5) b2 -- bias vector of shape (3, 1) W3 -- weight matrix of shape (1, 3) b3 -- bias vector of shape (1, 1) Returns: cost -- the cost function (logistic cost for one example) """ # retrieve parameters m = X.shape[1] W1 = parameters["W1"] b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] W3 = parameters["W3"] b3 = parameters["b3"] # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID Z1 = np.dot(W1, X) + b1 A1 = relu(Z1) Z2 = np.dot(W2, A1) + b2 A2 = relu(Z2) Z3 = np.dot(W3, A2) + b3 A3 = sigmoid(Z3) # Cost logprobs = np.multiply(-np.log(A3),Y) + np.multiply(-np.log(1 - A3), 1 - Y) cost = 1./m * np.sum(logprobs) cache = (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) return cost, cache ###Output _____no_output_____ ###Markdown Now, run backward propagation. ###Code def backward_propagation_n(X, Y, cache): """ Implement the backward propagation presented in figure 2. Arguments: X -- input datapoint, of shape (input size, 1) Y -- true "label" cache -- cache output from forward_propagation_n() Returns: gradients -- A dictionary with the gradients of the cost with respect to each parameter, activation and pre-activation variables. """ m = X.shape[1] (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache dZ3 = A3 - Y dW3 = 1./m * np.dot(dZ3, A2.T) db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True) dA2 = np.dot(W3.T, dZ3) dZ2 = np.multiply(dA2, np.int64(A2 > 0)) dW2 = 1./m * np.dot(dZ2, A1.T) db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True) dA1 = np.dot(W2.T, dZ2) dZ1 = np.multiply(dA1, np.int64(A1 > 0)) dW1 = 1./m * np.dot(dZ1, X.T) db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True) gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3, "dA2": dA2, "dZ2": dZ2, "dW2": dW2, "db2": db2, "dA1": dA1, "dZ1": dZ1, "dW1": dW1, "db1": db1} return gradients ###Output _____no_output_____ ###Markdown You obtained some results on the fraud detection test set but you are not 100% sure of your model. Nobody's perfect! Let's implement gradient checking to verify if your gradients are correct. **How does gradient checking work?**.As in 1) and 2), you want to compare "gradapprox" to the gradient computed by backpropagation. The formula is still:$$ \frac{\partial J}{\partial \theta} = \lim_{\varepsilon \to 0} \frac{J(\theta + \varepsilon) - J(\theta - \varepsilon)}{2 \varepsilon} \tag{1}$$However, $\theta$ is not a scalar anymore. It is a dictionary called "parameters". We implemented a function "`dictionary_to_vector()`" for you. It converts the "parameters" dictionary into a vector called "values", obtained by reshaping all parameters (W1, b1, W2, b2, W3, b3) into vectors and concatenating them.The inverse function is "`vector_to_dictionary`" which outputs back the "parameters" dictionary. **Figure 2** : **dictionary_to_vector() and vector_to_dictionary()** You will need these functions in gradient_check_n()We have also converted the "gradients" dictionary into a vector "grad" using gradients_to_vector(). You don't need to worry about that.**Exercise**: Implement gradient_check_n().**Instructions**: Here is pseudo-code that will help you implement the gradient check.For each i in num_parameters:- To compute `J_plus[i]`: 1. Set $\theta^{+}$ to `np.copy(parameters_values)` 2. Set $\theta^{+}_i$ to $\theta^{+}_i + \varepsilon$ 3. Calculate $J^{+}_i$ using to `forward_propagation_n(x, y, vector_to_dictionary(`$\theta^{+}$ `))`. - To compute `J_minus[i]`: do the same thing with $\theta^{-}$- Compute $gradapprox[i] = \frac{J^{+}_i - J^{-}_i}{2 \varepsilon}$Thus, you get a vector gradapprox, where gradapprox[i] is an approximation of the gradient with respect to `parameter_values[i]`. You can now compare this gradapprox vector to the gradients vector from backpropagation. Just like for the 1D case (Steps 1', 2', 3'), compute: $$ difference = \frac {\| grad - gradapprox \|_2}{\| grad \|_2 + \| gradapprox \|_2 } \tag{3}$$ ###Code # GRADED FUNCTION: gradient_check_n def gradient_check_n(parameters, gradients, X, Y, epsilon = 1e-7): """ Checks if backward_propagation_n computes correctly the gradient of the cost output by forward_propagation_n Arguments: parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3": grad -- output of backward_propagation_n, contains gradients of the cost with respect to the parameters. x -- input datapoint, of shape (input size, 1) y -- true "label" epsilon -- tiny shift to the input to compute approximated gradient with formula(1) Returns: difference -- difference (2) between the approximated gradient and the backward propagation gradient """ # Set-up variables parameters_values, _ = dictionary_to_vector(parameters) grad = gradients_to_vector(gradients) num_parameters = parameters_values.shape[0] J_plus = np.zeros((num_parameters, 1)) J_minus = np.zeros((num_parameters, 1)) gradapprox = np.zeros((num_parameters, 1)) # Compute gradapprox for i in range(num_parameters): # Compute J_plus[i]. Inputs: "parameters_values, epsilon". Output = "J_plus[i]". # "_" is used because the function you have to outputs two parameters but we only care about the first one ### START CODE HERE ### (approx. 3 lines) thetaplus = np.copy(parameters_values) # Step 1 thetaplus[i][0] += epsilon # Step 2 J_plus[i], _ = forward_propagation_n(X, Y, vector_to_dictionary(thetaplus)) # Step 3 ### END CODE HERE ### # Compute J_minus[i]. Inputs: "parameters_values, epsilon". Output = "J_minus[i]". ### START CODE HERE ### (approx. 3 lines) thetaminus = np.copy(parameters_values) # Step 1 thetaminus[i][0] -= epsilon # Step 2 J_minus[i], _ = forward_propagation_n(X, Y, vector_to_dictionary(thetaminus)) # Step 3 ### END CODE HERE ### # Compute gradapprox[i] ### START CODE HERE ### (approx. 1 line) gradapprox[i] = (J_plus[i] - J_minus[i]) / (2 * epsilon) ### END CODE HERE ### # Compare gradapprox to backward propagation gradients by computing difference. ### START CODE HERE ### (approx. 1 line) numerator = np.linalg.norm(gradapprox - grad) # Step 1' denominator = np.linalg.norm(gradapprox) + np.linalg.norm(grad) # Step 2' difference = numerator / denominator # Step 3' ### END CODE HERE ### if difference > 1e-7: print ("\033[93m" + "There is a mistake in the backward propagation! difference = " + str(difference) + "\033[0m") else: print ("\033[92m" + "Your backward propagation works perfectly fine! difference = " + str(difference) + "\033[0m") return difference X, Y, parameters = gradient_check_n_test_case() cost, cache = forward_propagation_n(X, Y, parameters) gradients = backward_propagation_n(X, Y, cache) difference = gradient_check_n(parameters, gradients, X, Y) ###Output There is a mistake in the backward propagation! difference = 1.18904178788e-07
Unsupervised Analysis of Days of Week.ipynb
###Markdown Unsupervised Analysis of Days of WeekTreating crossings each day as features to learn about the relationships between various day ###Code %matplotlib inline import matplotlib.pyplot as plt plt.style.use('seaborn') import pandas as pd import numpy as np from sklearn.decomposition import PCA from sklearn.mixture import GaussianMixture ###Output _____no_output_____ ###Markdown Get data ###Code from data import get_fremont_data data = get_fremont_data() pivoted = data.pivot_table('Fremont Bridge Total', index=data.index.time, columns=data.index.date) pivoted.plot(legend=False, alpha=0.01) ###Output C:\Users\user\Downloads\Github\JupyterWorkflow\data.py:33: UserWarning: Pandas doesn't allow columns to be created via a new attribute name - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute-access data.column = ['Weat', 'East'] ###Markdown Principal Component Analysis ###Code X =pivoted.fillna(0).T.values X.shape X2=PCA(2, svd_solver='full').fit_transform(X) X2.shape plt.scatter(X2[:, 0], X2[:, 1]) ###Output _____no_output_____ ###Markdown Unsupervised Clusering ###Code gmm =GaussianMixture(2).fit(X) labels = gmm.predict(X) plt.scatter(X2[:, 0], X2[:, 1], c=labels, cmap='rainbow') plt.colorbar() fig, ax=plt.subplots(1, 2, figsize=(4, 6)) pivoted.T[labels == 0].T.plot(legend=False, alpha=0.1, ax=ax[0]) pivoted.T[labels == 1].T.plot(legend=False, alpha=0.1, ax=ax[1]) ax[0].set_title('Purple Cluster') ax[1].set_title('Red Cluster') ###Output _____no_output_____ ###Markdown Comparing with Day of Week ###Code dayofweek = pd.DatetimeIndex(pivoted.columns).dayofweek plt.scatter(X2[:, 0], X2[:, 1], c=dayofweek, cmap='rainbow') plt.colorbar() ###Output _____no_output_____ ###Markdown Analyzing Outlierswith holiday-like pattern ###Code dates = pd.DatetimeIndex(pivoted.columns) dates[(labels == 1) & (dayofweek <5)] ###Output _____no_output_____
notebooks/constant_selection.ipynb
###Markdown Constant selection![constant selection](../resources/constant_selection.png) ###Code import numpy as np import matplotlib.pyplot as plt from tqdm.notebook import tqdm import ipywidgets as widgets %matplotlib inline %matplotlib widget ###Output _____no_output_____ ###Markdown The Moran model + constant selectionThe difference, the _only_ difference, between this and the original Moran model is that we now consider fitness in who we select when drawing an individual to reproduce. Before we considered each individual equally but now we weight individuals of each species using their fitness. we represent this weighting by the `fit_ratio` parameter which described the ratio between species 1 fitness($k_1$) and species 2 fitness ($k_2$). Inorder to do this weighting without violating the rule that the probabilities of each species must add up to 1, we do the weighting like this:$$P_{birth}(S=1) = \frac{(k_1/k_2) f_1}{(k_1/k_2) f_1 + f_2}$$This is the only change we have to make to the basic Moran model to introduce constant selection, and we will never have to consider the individual species' fitnesses on their own. Temporally varying selectionVellend also introduces a 'temporally varying' selection. He introduces this after frequency dependence but his model is more like this constant selection model so we will consider that here. In Vellend's description, the change in time comes as a change in the fitness ratio that depends on the simulated year.First let's say that we've arrived at our fitness ratio, we'll call this $\gamma$\begin{align}\frac{k_1}{k_2} = \gamma\end{align}We do the temporal variation, at least the simple example vellend shows, by flipping the ratio every 10 years. In general we flip the ratio every $y_{flip}$ years. When we've gone through $y_{flip}$ years we simple redefine the fitness ratio as:\begin{align}\frac{k_1}{k_2} = \gamma^{-1}\end{align}I've represented this in the code with a variable called `time_dep` that can either be `True` or `False`. If its true, we do the 10 year flip as shown in the chapter. ###Code def moran_constant_selection(n_indiv, n_years, init_f1, fit_ratio, time_dep): """ Implements the Moran model including constant selection and simulates it in time. Parameters ---------- n_indiv: int number of individuals in the community n_years: int number of potential 'turnovers' of the community init_f1: float initial frequency of species 1 fit_ratio: float ratio of fitness of species 1 to fitness of species 2 Return ------ moran: np.array (n_years, 2) contains the species frequencies for each year of the simulation """ # set up an empty array for the simulated frequencies # initialize with the given frequency. python counts from 0, sorrryyyy moran = np.zeros((n_years, 2)) moran[0] = np.array([init_f1, 1 - init_f1]) # get a vector representing the community. vellend calls this COM # this just makes a random vector drawn from the initial frequency comm = np.random.choice([0, 1], size=n_indiv, replace=True, p=moran[0]) # now we can do the loop as in vellend. I'm going to write it a bit differently # but the idea is basically the same. (yes its slower) for year in range(1, n_years): # if time dependence is true we flip the fitness ratio every ten years if time_dep and year % 10 == 0: fit_ratio = fit_ratio**-1 # for each year we potentially replace each individual so we can loop # over that as well for indiv in range(n_indiv): # get probability of species 1 f1 = np.sum(comm == 0) / n_indiv pr1 = fit_ratio * f1 / (fit_ratio * f1 + (1 - f1)) # replace one individual with another death = np.random.randint(n_indiv) birth = np.random.choice([0, 1], p=[pr1, 1 - pr1]) comm[death] = birth # when we're done looping over all of the individuals we can update # frequencies for the year (the timescale we care about) f1 = np.sum(comm == 0) / n_indiv moran[year] = np.array([f1, 1 - f1]) return moran ###Output _____no_output_____ ###Markdown Running the simulations and visualizationAs before we have a bunch of messy code to draw the plots. Once again we can change parameter values in the first block and not worry about the rest (unless you want to!) ###Code def draw_simulation(iterations=10, individuals=250, years=50, initial_freq=0.5, fit_ratio=1, time_dep=False): # the plot bit, this just makes a blank plot fig, ax = plt.subplots(ncols=2, figsize=(10,4), sharey=True, gridspec_kw = {'width_ratios':[3, 1]}) # trajectory labels ax[0].set_xlabel('Years') ax[0].set_ylabel('Species 1 frequency') ax[0].set_ylim([0, 1]) # distribution labels and bins hist_bins = np.arange(0, 1.1, 0.1) ax[1].set_xlabel('Count') ax[1].set_xlim([0, iterations]) # we're going to plot a distribution too need an array for it dist = np.zeros(iterations) # we run the simulation and draw a trajectory for i in tqdm(range(iterations)): simulation = moran_constant_selection(individuals, years, initial_freq, fit_ratio, time_dep) ax[0].plot(range(years), simulation[:, 0], c='C0') # add final freq to our dist array dist[i] = simulation[-1, 0] # plot the distribution too ax[1].hist(dist, bins=hist_bins, orientation='horizontal') ax[1].axhline(np.mean(dist), linestyle='--') plt.tight_layout() plt.show() # set up the interface widgets.interact_manual(draw_simulation, iterations=(5, 50, 5), individuals=(10, 1000, 10), years=(5, 200, 5), initial_freq=(0.0, 1.0, 0.01), fit_ratio=(0.67, 1.5, 0.01), time_dep=(False)) ###Output _____no_output_____
vol2_v2/extractor_asis14.ipynb
###Markdown Extract barrier island metrics along transectsAuthor: Emily Sturdivant, [email protected]***Extract barrier island metrics along transects for Barrier Island Geomorphology Bayesian Network. See the project [README](https://github.com/esturdivant-usgs/BI-geomorph-extraction/blob/master/README.md) and the Methods Report (Zeigler et al., in review). Pre-requisites:- All the input layers (transects, shoreline, etc.) must be ready. This is performed with the notebook file prepper.ipynb.- The files servars.py and configmap.py may need to be updated for the current dataset. Notes:- This notebook includes interactive quality checking, which requires the user's attention. For thorough QC'ing, we recommend displaying the layers in ArcGIS, especially to confirm the integrity of values for variables such as distance to inlet (__Dist2Inlet__) and widths of the landmass (__WidthPart__, etc.). *** Import modules ###Code import os import sys import pandas as pd import numpy as np import io import arcpy import pyproj import matplotlib.pyplot as plt import matplotlib matplotlib.style.use('ggplot') import core.functions_warcpy as fwa import core.functions as fun print("Date: {}".format(datetime.date.today())) # print(os.__version__) # print(sys.__version__) print('pandas version: {}'.format(pd.__version__)) print('numpy version: {}'.format(np.__version__)) print('matplotlib version: {}'.format(matplotlib.__version__)) # print(io.__version__) # print(arcpy.__version__) print('pyproj version: {}'.format(pyproj.__version__)) # print(bi_transect_extractor.__version__) ###Output Date: 2019-10-08 pandas version: 0.20.3 numpy version: 1.13.1 matplotlib version: 1.5.3 pyproj version: 1.9.5.1 ###Markdown Initialize variablesThis cell prompts you for the site, year, and project directory path. `setvars.py` retrieves the pre-determined values for that site in that year from `configmap.py`. The project directory will be used to set up your workspace. It's hidden for security – sorry! I recommend that you type the path somewhere and paste it in. ###Code from core.setvars import * ###Output site (options: Metompkin, RhodeIsland, ShipShoal, Cedar, Fisherman, Wreck, CapeHatteras, ParkerRiver, Monomoy, Assawoman, Parramore, Myrtle, Assateague, Forsythe, Smith, CapeLookout, Cobb, CoastGuard, FireIsland, Rockaway): Assateague year (options: 2010, 2012, 2014): 2014 Path to project directory (e.g. \\Mac olume\dir\FireIsland2014): ··············································· ###Markdown Change the filename variables to match your local files. They should be in an Esri file geodatabase named site+year.gdb in your project directory, which you input above and is the value of the variable `home`. ###Code # Extended transects: NASC transects extended and sorted, ready to be the base geometry for processing extendedTrans = os.path.join(home, 'extTrans') # Tidied transects: Extended transects without overlapping transects extTrans_tidy = os.path.join(home, 'tidyTrans') # Geomorphology points: positions of indicated geomorphic features ShorelinePts = os.path.join(home, 'SLpts') # shoreline dlPts = os.path.join(home, 'DLpts') # dune toe dhPts = os.path.join(home, 'DHpts') # dune crest # Inlet lines: polyline feature classes delimiting inlet position. Must intersect the full island shoreline inletLines = os.path.join(home, 'Assateague2014_inletLines') # Full island shoreline: polygon that outlines the island shoreline, MHW on oceanside and MTL on bayside barrierBoundary = os.path.join(home, 'bndpoly_2sl') # Elevation grid: DEM of island elevation at either 5 m or 1 m resolution elevGrid = os.path.join(home, 'DEM_rasterdataset') # --- # OPTIONAL - comment out each one that is not available # --- # # morphdata_prefix = '14CNT01' # Study area boundary; manually digitize if the barrier island study area does not end at an inlet. SA_bounds = os.path.join(home, 'SA_bounds') # Armoring lines: digitize lines of shorefront armoring to be used if dune toe points are not available. armorLines = os.path.join(home, 'armorLines') # Extended transects with Construction, Development, and Nourishment coding tr_w_anthro = os.path.join(home, 'extTrans_wAnthro') # Piping Plover Habitat BN raster layers SubType = os.path.join(home, 'ASIS14_SubType') # substrate type VegType = os.path.join(home, 'ASIS14_VegType') # vegetation type VegDens = os.path.join(home, 'ASIS14_VegDen') # vegetation density GeoSet = os.path.join(home, 'ASIS14_GeoSet') # geomorphic setting # Derivatives of inputs: They will be generated during process if they are not found. shoreline = os.path.join(home, 'ShoreBetweenInlets') # oceanside shoreline between inlets; generated from shoreline polygon, inlet lines, and SA bounds slopeGrid = os.path.join(home, 'slope_5m') # Slope at 5 m resolution; generated from DEM ###Output _____no_output_____ ###Markdown Transect-averaged valuesWe work with the shapefile/feature class as a pandas DataFrame as much as possible to speed processing and minimize reliance on the ArcGIS GUI display.1. Add the bearing of each transect line to the attribute table from the LINE_BEARING geometry attribute.1. Create a pandas dataframe from the transects feature class. In the process, remove some of the unnecessary fields. The resulting dataframe is indexed by __sort_ID__ with columns corresponding to the attribute fields in the transects feature class. 2. Add __DD_ID__.3. Join the values from the transect file that includes the three anthropologic development fields, __Construction__, __Development__, and __Nourishment__. ###Code # Add BEARING field to extendedTrans feature class arcpy.AddGeometryAttributes_management (extendedTrans, 'LINE_BEARING') print("Adding line bearing field to transects.") # Copy feature class to dataframe. trans_df = fwa.FCtoDF(extendedTrans, id_fld=tID_fld, extra_fields=extra_fields) # Set capitalization of fields to match expected colrename = {} for f in sorted_pt_flds: for c in trans_df.columns: if f.lower() == c.lower() and f != c: colrename[c] = f print("Renaming {} to {}".format(c, f)) trans_df.rename(columns=colrename, inplace=True) # Set DD_ID, MHW, and Azimuth fields trans_df['DD_ID'] = trans_df[tID_fld] + sitevals['id_init_val'] trans_df['MHW'] = sitevals['MHW'] trans_df.drop('Azimuth', axis=1, inplace=True, errors='ignore') trans_df.rename_axis({"BEARING": "Azimuth"}, axis=1, inplace=True) # Get anthro fields and join to DF if 'tr_w_anthro' in locals(): trdf_anthro = fwa.FCtoDF(tr_w_anthro, id_fld=tID_fld, dffields=['Development', 'Nourishment','Construction']) trans_df = fun.join_columns(trans_df, trdf_anthro) # Save trans_df.to_pickle(os.path.join(scratch_dir, 'trans_df.pkl')) # Display print("\nHeader of transects dataframe (rows 1-5 out of {}): ".format(len(trans_df))) trans_df.head() trans_df.loc[:,['TRANSECTID', 'Azimuth', 'LRR', 'sort_ID', 'DD_ID', 'MHW', 'Development']].sample(10) ###Output _____no_output_____ ###Markdown Get XY and Z/slope from SL, DH, DL points within 25 m of transectsAdd to each transect row the positions of the nearest pre-created beach geomorphic features (shoreline, dune toe, and dune crest). If needed, convert morphology points stored locally to feature classes for use.After which, view the new feature classes in a GIS. Isolate the points to the region of interest. Quality check them. Then copy them for use with this code, which will require setting the filenames to match those included here or changing the values included here to match the final filenames. ###Code if "morphdata_prefix" in locals(): csvpath = os.path.join(proj_dir, 'Input_Data', '{}_morphology'.format(morphdata_prefix), '{}_morphology.csv'.format(morphdata_prefix)) dt_fc, dc_fc, sl_fc = fwa.MorphologyCSV_to_FCsByFeature(csvpath, state, proj_code, csv_fill = 999, fc_fill = -99999, csv_epsg=4326) print("OUTPUT: morphology point feature classes in the scratch gdb. We recommend QC before proceeding.") ###Output _____no_output_____ ###Markdown ShorelineThe MHW shoreline easting and northing (__SL_x__, __SL_y__) are the coordinates of the intersection of the oceanside shoreline with the transect. Each transect is assigned the foreshore slope (__Bslope__) from the nearest shoreline point within 25 m. These values are populated for each transect as follows: 1. get __SL_x__ and __SL_y__ at the point where the transect crosses the oceanside shoreline; 2. find the closest shoreline point to the intersection point (must be within 25 m) and copy the slope value from the point to the transect in the field __Bslope__. ###Code if not arcpy.Exists(inletLines): # manually create lines that correspond to end of land and cross the MHW line (refer to shoreline polygon) arcpy.CreateFeatureclass_management(home, os.path.basename(inletLines), 'POLYLINE', spatial_reference=utmSR) print("OUTPUT: {}. Interrupt execution to manually create lines at each inlet.".format(inletLines)) if not arcpy.Exists(shoreline): if not 'SA_bounds' in locals(): SA_bounds = '' shoreline = fwa.CreateShoreBetweenInlets(barrierBoundary, inletLines, shoreline, ShorelinePts, proj_code, SA_bounds) # Get the XY position where transect crosses the oceanside shoreline sl2trans_df, ShorelinePts = fwa.add_shorelinePts2Trans(extendedTrans, ShorelinePts, shoreline, tID_fld, proximity=pt2trans_disttolerance) # Save and print sample sl2trans_df.to_pickle(os.path.join(scratch_dir, 'sl2trans.pkl')) sl2trans_df.sample(5) # Export the inlet delineation and shoreline polygons to the scratch directory ultimately for publication arcpy.FeatureClassToFeatureClass_conversion(inletLines, scratch_dir, pts_name.split('_')[0] + '_inletLines.shp') arcpy.FeatureClassToFeatureClass_conversion(barrierBoundary, scratch_dir, pts_name.split('_')[0] + '_shoreline.shp') print('OUTPUT: Saved inletLines and shoreline shapefiles in the scratch directory.') fwa.pts_to_csv_and_eainfoxml(ShorelinePts, '_SLpts', scratch_dir, pts_name, field_defs, fill) ###Output ...converting feature class to array... ...converting array to dataframe... Number of points in dataset: (6039, 10) OBJECTID_______________________________1 | 6047________________ No fills_________No nulls Shape............... nan state............... 12 | 13 seg____________________________________1 | 88__________________ No fills_________No nulls profile________________________________1 | 797_________________ No fills_________No nulls sl_x_________________________-685.332759 | 497.819121__________ No fills_________No nulls ci95_slx_____________________________0.0 | 0.848279____________ No fills_________No nulls slope__________________________-0.231863 | -0.000548___________ No fills_________No nulls easting____________________464785.199053 | 491903.892334_______ No fills_________No nulls northing__________________4189226.119702 | 4241668.023755______ No fills_________No nulls OUTPUT: asis14_SLpts.shp in specified scratch_dir. OUTPUT: asis14_SLpts.csv (size: 0.46 MB) in specified scratch_dir. ###Markdown Dune positions along transects__DL_x__, __DL_y__, and __DL_z__ are the easting, northing, and elevation, respectively, of the nearest dune toe point within 25 meters of the transect. __DH_x__, __DH_y__, and __DH_z__ are the easting, northing, and elevation, respectively, of the nearest dune crest point within 25 meters. __DL_snapX__, __DL_snapY__, __DH_snapX__, and __DH_snapY__ are the eastings and northings of the points "snapped" to the transect. "Snapping" finds the position along the transect nearest to the point, i.e. orthogonal to the transect. These values are used to find the beach width. The elevation values are not snapped; we use the elevation values straight from the original points. These values are populated as follows: 1. Find the nearest dune crest/toe point to the transect and proceed if the distance is less than 25 m. If there are no points within 25 m of the transect, populate the row with Null values.2. Get the X, Y, and Z values of the point. 3. Find the position along the transect of an orthogonal line drawn to the dune point (__DL_snapX__, __DL_snapY__, __DH_snapX__, and __DH_snapY__). This is considered the 'snapped' XY position and is calculated using the arcpy geometry method. ###Code # Create dataframe for both dune crest and dune toe positions dune2trans_df, dhPts, dlPts = fwa.find_ClosestPt2Trans_snap(extendedTrans, dhPts, dlPts, trans_df, tID_fld, proximity=pt2trans_disttolerance) # Save and print sample dune2trans_df.to_pickle(os.path.join(scratch_dir, 'dune2trans.pkl')) dune2trans_df.sample(5) fwa.pts_to_csv_and_eainfoxml(dlPts, '_DTpts', scratch_dir, pts_name, field_defs, fill) fwa.pts_to_csv_and_eainfoxml(dhPts, '_DCpts', scratch_dir, pts_name, field_defs, fill) ###Output ...converting feature class to array... ...converting array to dataframe... Number of points in dataset: (4493, 12) OBJECTID_______________________________1 | 4493________________ No fills_________No nulls Shape............... nan state............... 12 | 13 seg____________________________________1 | 88__________________ No fills_________No nulls profile________________________________1 | 797_________________ No fills_________No nulls lon___________________________-75.394665 | -75.093626__________ No fills_________No nulls lat____________________________37.850433 | 38.323336___________ No fills_________No nulls easting____________________465288.623404 | 491816.106114_______ No fills_________No nulls northing__________________4189290.483995 | 4241695.00959_______ No fills_________No nulls dlow_x_______________________-782.018865 | 431.256053__________ No fills_________No nulls dlow_z___________________________1.02095 | 4.892596____________ No fills_________No nulls z_error__________________________0.00852 | 1.005295____________ No fills_________No nulls OUTPUT: asis14_DTpts.shp in specified scratch_dir. OUTPUT: asis14_DTpts.csv (size: 0.43 MB) in specified scratch_dir. ...converting feature class to array... ...converting array to dataframe... Number of points in dataset: (5342, 12) OBJECTID______________________________21 | 5396________________ No fills_________No nulls Shape............... nan state............... 12 | 13 seg____________________________________1 | 88__________________ No fills_________No nulls profile________________________________1 | 797_________________ No fills_________No nulls lon___________________________-75.400129 | -75.093738__________ No fills_________No nulls lat____________________________37.850653 | 38.323387___________ No fills_________No nulls easting____________________464808.940908 | 491806.330672_______ No fills_________No nulls northing__________________4189314.991735 | 4241700.577644______ No fills_________No nulls dhigh_x______________________-823.268865 | 488.756053__________ No fills_________No nulls dhigh_z_________________________0.929257 | 7.995073____________ No fills_________No nulls z_error_________________________0.005932 | 0.904903____________ No fills_________No nulls OUTPUT: asis14_DCpts.shp in specified scratch_dir. OUTPUT: asis14_DCpts.csv (size: 0.51 MB) in specified scratch_dir. ###Markdown Armoring__Arm_x__, __Arm_y__, and __Arm_z__ are the easting, northing, and elevation, respectively, where an artificial structure crosses the transect in the vicinity of the beach. These features are meant to supplement the dune toe data set by providing an upper limit to the beach in areas where dune toe extraction was confounded by the presence of an artificial structure. Values are populated for each transect as follows: 1. Get the positions of intersection between the digitized armoring lines and the transects (Intersect tool from the Overlay toolset); 2. Extract the elevation value at each intersection point from the DEM (Extract Multi Values to Points tool from Spatial Analyst); ###Code # Create elevation raster at 5-m resolution if not already elevGrid = fwa.ProcessDEM_2(elevGrid, utmSR) # Armoring line if not arcpy.Exists(armorLines): arcpy.CreateFeatureclass_management(home, os.path.basename(armorLines), 'POLYLINE', spatial_reference=utmSR) print("{} created. If shorefront armoring exists, interrupt execution to manually digitize.".format(armorLines)) arm2trans_df = fwa.ArmorLineToTrans_PD(extendedTrans, armorLines, sl2trans_df, tID_fld, proj_code, elevGrid) # Save and print sample arm2trans_df.to_pickle(os.path.join(scratch_dir, 'arm2trans.pkl')) try: arm2trans_df.sample(5) except: pass ###Output OUTPUT: DEM_rasterdataset_5m at 5x5 resolution. \\Mac\stor\Projects\DeepDive\TE_vol2\Assateague\Assateague2014.gdb\armorLines created. If shorefront armoring exists, interrupt execution to manually digitize. Armoring file either missing or empty so we will proceed without armoring data. If shorefront tampering is present at this site, cancel the operations to digitize. ###Markdown Add all the positions to the trans_dfJoin the new dataframes to the transect dataframe. Before it performs the join, `join_columns_id_check()` checks the index and the ID field for potential errors such as whether they are the equal and whether there are duplicated IDs or null values in either. ###Code # Load saved dataframes trans_df = pd.read_pickle(os.path.join(scratch_dir, 'trans_df.pkl')) sl2trans_df = pd.read_pickle(os.path.join(scratch_dir, 'sl2trans.pkl')) dune2trans_df = pd.read_pickle(os.path.join(scratch_dir, 'dune2trans.pkl')) arm2trans_df = pd.read_pickle(os.path.join(scratch_dir, 'arm2trans.pkl')) # Join positions of shoreline, dune crest, dune toe, armoring trans_df = fun.join_columns_id_check(trans_df, sl2trans_df, tID_fld) trans_df = fun.join_columns_id_check(trans_df, dune2trans_df, tID_fld) trans_df = fun.join_columns_id_check(trans_df, arm2trans_df, tID_fld) # Save and print sample trans_df.to_pickle(os.path.join(scratch_dir, 'trans_df_beachmetrics.pkl')) trans_df.loc[:,['sort_ID', 'DD_ID', 'TRANSECTID', 'MHW', 'SL_x', 'Bslope', 'DH_z', 'DL_z']].sample(10) ###Output ...checking ID field(s) for df2 (join)... ...checking ID field(s) for df2 (join)... ...checking ID field(s) for df2 (join)... ###Markdown Check for errors*Optional*Display summary stats / histograms and create feature classes. The feature classes display the locations that will be used to calculate beach width. Review the output feature classes in a GIS to validate. ###Code plots = trans_df.hist(['DH_z', 'DL_z', 'Arm_z']) # Subplot Labels plots[0][0].set_xlabel("Elevation (m in NAVD88)") plots[0][0].set_ylabel("Frequency") plots[0][1].set_xlabel("Elevation (m in NAVD88)") plots[0][1].set_ylabel("Frequency") try: plots[0][2].set_xlabel("Elevation (m in NAVD88)") plots[0][2].set_ylabel("Frequency") except: pass plt.show() plt.close() # Convert dataframe to feature class - shoreline points with slope fwa.DFtoFC(sl2trans_df, os.path.join(arcpy.env.workspace, 'pts2trans_SL'), spatial_ref=utmSR, id_fld=tID_fld, xy=["SL_x", "SL_y"], keep_fields=['Bslope']) print('OUTPUT: pts2trans_SL in designated scratch geodatabase.') # Dune crests try: fwa.DFtoFC(dune2trans_df, os.path.join(arcpy.env.workspace, 'ptSnap2trans_DH'), spatial_ref=utmSR, id_fld=tID_fld, xy=["DH_snapX", "DH_snapY"], keep_fields=['DH_z']) print('OUTPUT: ptSnap2trans_DH in designated scratch geodatabase.') except Exception as err: print(err) pass # Dune toes try: fwa.DFtoFC(dune2trans_df, os.path.join(arcpy.env.workspace, 'ptSnap2trans_DL'), spatial_ref=utmSR, id_fld=tID_fld, xy=["DL_snapX", "DL_snapY"], keep_fields=['DL_z']) print('OUTPUT: ptSnap2trans_DL in designated scratch geodatabase.') except Exception as err: print(err) pass ###Output ... converting dataframe to array... ... converting array to feature class... OUTPUT: pts2trans_SL in designated scratch geodatabase. ... converting dataframe to array... ... converting array to feature class... OUTPUT: ptSnap2trans_DH in designated scratch geodatabase. ... converting dataframe to array... ... converting array to feature class... OUTPUT: ptSnap2trans_DL in designated scratch geodatabase. ###Markdown Calculate upper beach width and heightUpper beach width (__uBW__) and upper beach height (__uBH__) are calculated based on the difference in position between two points: the position of MHW along the transect (__SL_x__, __SL_y__) and the dune toe position or equivalent (usually __DL_snapX__, __DL_snapY__). In some cases, the dune toe is not appropriate to designate the "top of beach" so beach width and height are calculated from either the position of the dune toe, the dune crest, or the base of an armoring structure. The dune crest was only considered a possibility if the dune crest elevation (__DH_zMHW__) was less than or equal to `maxDH`. They are calculated as follows: 2. Calculate distances from MHW to the position along the transect of the dune toe (__DistDL__), dune crest (__DistDH__), and armoring (__DistArm__). 2. Adjust the elevations to MHW, populating fields __DH_zmhw__, __DL_zmhw__, and __Arm_zmhw__. 3. Conditionally select the appropriate feature to represent "top of beach." Dune toe is prioritized. If it is not available and __DH_zmhw__ is less than or equal to maxDH, use dune crest. If neither of the dune positions satisfy the conditions and an armoring feature intersects with the transect, use the armoring position. If none of the three are possible, __uBW__ and __uBH__ will be null. 4. Copy the distance to shoreline and height above MHW (__Dist--__, __---zmhw__) to __uBW__ and __uBH__, respectively. Notes:- In some morphology datasets, missing elevation values at a point indicate that the point should not be used to measure beach width. In those cases, use the `skip_missing_z` argument to select whether or not to skip these points. ###Code # Load saved dataframe trans_df = pd.read_pickle(os.path.join(scratch_dir, 'trans_df_beachmetrics.pkl')) # Calculate distances from shore to dunes, etc. trans_df = fwa.calc_BeachWidth_fill(extendedTrans, trans_df, maxDH, tID_fld, sitevals['MHW'], fill, skip_missing_z=True) ###Output ...checking ID field(s) for df2 (join)... Fields uBW and uBH populated with beach width and beach height. ###Markdown Dist2InletDistance to nearest tidal inlet (__Dist2Inlet__) is computed as alongshore distance of each sampling transect from the nearest tidal inlet. This distance includes changes in the path of the shoreline instead of simply a Euclidean distance and reflects sediment transport pathways. It is measured using the oceanside shoreline between inlets (ShoreBetweenInlets). Note that the ShoreBetweenInlets feature class must be both 'dissolved' and 'singlepart' so that each feature represents one-and-only-one shoreline that runs the entire distance between two inlets or equivalent. If the shoreline is bounded on both sides by an inlet, measure the distance to both and assign the minimum distance of the two. If the shoreline meets only one inlet (meaning the study area ends before the island ends), use the distance to the only inlet. The process uses the cut, disjoint, and length geometry methods and properties in ArcPy data access module. The function measure_Dist2Inlet() prints a warning when the difference in Dist2Inlet between two consecutive transects is greater than 300. ###Code # Calc Dist2Inlet in new dataframe dist_df = fwa.measure_Dist2Inlet(shoreline, extendedTrans, inletLines, tID_fld) # Join to transects trans_df = fun.join_columns_id_check(trans_df, pd.DataFrame(dist_df.Dist2Inlet), tID_fld, fill=fill) # Save and view last 10 rows dist_df.to_pickle(os.path.join(scratch_dir, 'dist2inlet_df.pkl')) dist_df.tail(10) ###Output CAUTION: Large change in Dist2Inlet values between transects 21 (3 3.580595 Name: Dist2Inlet, dtype: float64 m) and 22 (666.1722765582263 m). CAUTION: Large change in Dist2Inlet values between transects 46 (28 2207.49022 Name: Dist2Inlet, dtype: float64 m) and 47 (2663.276674527246 m). CAUTION: Large change in Dist2Inlet values between transects 85 (67 6669.116191 Name: Dist2Inlet, dtype: float64 m) and 86 (5732.512161078799 m). Duration: 0:0:38.9 seconds ...checking ID field(s) for df2 (join)... ###Markdown Clip transects, get barrier widthsCalculates __WidthLand__, __WidthFull__, and __WidthPart__, which measure different flavors of the cross-shore width of the barrier island. __WidthLand__ is the above-water distance between the back-barrier and seaward MHW shorelines. __WidthLand__ only includes regions of the barrier within the shoreline polygon (bndpoly_2sl) and does not extend into any of the sinuous or intervening back-barrier waterways and islands. __WidthFull__ is the total distance between the back-barrier and seaward MHW shorelines (including space occupied by waterways). __WidthPart__ is the width of only the most seaward portion of land within the shoreline. These are calculated as follows: 1. Clip the transect to the full island shoreline (Clip in the Analysis toolbox); 2. For __WidthLand__, get the length of the multipart line segment from &quot;SHAPE@LENGTH&quot; feature class attribute. When the feature is multipart, this will include only the remaining portions of the transect; 3. For __WidthPart__, convert the clipped transect from multipart to singlepart and get the length of the first line segment, which should be the most seaward; 4. For __WidthFull__, calculate the distance between the first vertex and the last vertex of the clipped transect (Feature Class to NumPy Array with explode to points, pandas groupby, numpy hypot). ###Code # Clip transects, get barrier widths widths_df = fwa.calc_IslandWidths(extendedTrans, barrierBoundary, tID_fld=tID_fld) # # Save widths_df.to_pickle(os.path.join(scratch_dir, 'widths_df.pkl')) # Join trans_df = fun.join_columns_id_check(trans_df, widths_df, tID_fld, fill=fill) # Save trans_df.to_pickle(os.path.join(scratch_dir, trans_name+'_null_prePts.pkl')) trans_df.loc[:,['sort_ID', 'WidthLand', 'WidthPart', 'WidthFull', 'Dist2Inlet', 'uBW']].sample(10) ###Output _____no_output_____ ###Markdown 5-m PointsThe point dataset samples the land every 5 m along each shore-normal transect. Split transects into points at 5-m intervals. The point dataset is created from the tidied transects (tidyTrans, created during pre-processing) as follows: 1. Clip the tidied transects (tidyTrans) to the shoreline polygon (bndpoly_2sl) , retaining only those portions of the transects that represent land.2. Produce a dataframe of point positions along each transect every 5 m starting from the ocean-side shoreline. This uses the positionAlongLine geometry method accessed with a Search Cursor and saves the outputs in a new dataframe. 3. Create a point feature class from the dataframe. Note: Sometimes the system doesn't seem to register the new feature class (transPts_unsorted) for a while. I'm not sure how to work around that, other than just to wait. ###Code pts_df, pts_presort = fwa.TransectsToPointsDF(extTrans_tidy, barrierBoundary, fc_out=pts_presort) print("OUTPUT: '{}' in scratch geodatabase.".format(os.path.basename(pts_presort))) # Save pts_df.to_pickle(os.path.join(scratch_dir, 'pts_presort.pkl')) ###Output Clipping transects to within the shoreline bounds ('tidytrans_clipped')... Getting points every 5m along each transect and saving in new dataframe... Converting dataframe to feature class ('transPts_unsorted')... ... converting dataframe to array... ... converting array to feature class... Duration: 0:29:6.8 seconds OUTPUT: 'transPts_unsorted' in scratch geodatabase. ###Markdown Add Elevation and Slope to points__ptZ__ (later __ptZmhw__) and __ptSlp__ are the elevation and slope at the 5-m cell corresponding to the point. 1. Create the slope and DEM rasters if they don't already exist. We use the 5-m DEM to generate a slope surface (Slope tool in 3D Analyst). 2. Use Extract Multi Values to Points tool in Spatial Analyst. 3. Convert the feature class back to a dataframe. ###Code # Elevation grid: DEM of island elevation at either 5 m or 1 m resolution elevGrid = os.path.join(home, 'DEM_rasterdataset') arcpy.Exists(slopeGrid) # Create slope raster from DEM if not arcpy.Exists(slopeGrid): arcpy.Slope_3d(elevGrid, slopeGrid, 'PERCENT_RISE') print("OUTPUT: slope file in designated home geodatabase.") # Add elevation and slope values at points. arcpy.sa.ExtractMultiValuesToPoints(pts_presort, [[elevGrid, 'ptZ'], [slopeGrid, 'ptSlp']]) print("OUTPUT: added slope and elevation to '{}' in designated scratch geodatabase.".format(os.path.basename(pts_presort))) if 'SubType' in locals(): # Add substrate type, geomorphic setting, veg type, veg density values at points. arcpy.sa.ExtractMultiValuesToPoints(pts_presort, [[SubType, 'SubType'], [VegType, 'VegType'], [VegDens, 'VegDens'], [GeoSet, 'GeoSet']]) # Convert to dataframe pts_df = fwa.FCtoDF(pts_presort, xy=True, dffields=[tID_fld,'ptZ', 'ptSlp', 'SubType', 'VegType', 'VegDens', 'GeoSet']) # Recode fill values pts_df.replace({'GeoSet': {9999:np.nan}, 'SubType': {9999:np.nan}, 'VegType': {9999:np.nan}, 'VegDens': {9999:np.nan}}, inplace=True) else: print("Plover BN layers not specified (we only check for SubType), so we'll proceed without them. ") # Convert to dataframe pts_df = fwa.FCtoDF(pts_presort, xy=True, dffields=[tID_fld,'ptZ', 'ptSlp']) # Convert new fields to appropriate types pts_df = pts_df.astype({'ptZ':'float64', 'ptSlp':'float64'}) # Save and view sample pts_df.to_pickle(os.path.join(scratch_dir, 'pts_extractedvalues_presort.pkl')) pts_df.loc[:,['SplitSort', 'DD_ID', 'TRANSECTID', 'GeoSet', 'SubType', 'VegType', 'VegDens', 'ptZ', 'ptSlp']].sample(10) # Print histogram of elevation extracted to points plots = pts_df.hist('ptZ') # Subplot Labels plots[0][0].set_xlabel("Elevation (m in NAVD88)") plots[0][0].set_ylabel("Frequency") # Display plt.show() plt.close() ###Output _____no_output_____ ###Markdown Calculate distances and sort points__SplitSort__ is a unique numeric identifier of the 5-m points at the study site, sorted by order along shoreline and by distance from oceanside. __SplitSort__ values are populated by sorting the points by __sort_ID__ and __Dist_Seg__ (see below). __Dist_Seg__ is the Euclidean distance between the point and the seaward shoreline (__SL_x__, __SL_y__). __Dist_MHWbay__ is the distance between the point and the bayside shoreline and is calculated by subtracting the __Dist_Seg__ value from the __WidthPart__ value of the transect. __DistSegDH__, __DistSegDL__, and __DistSegArm__ measure the distance of each 5-m point from the dune crest and dune toe position along a particular transect. They are calculated as the Euclidean distance between the 5-m point and the given feature. ###Code # Load saved dataframes pts_df = pd.read_pickle(os.path.join(scratch_dir, 'pts_extractedvalues_presort.pkl')) trans_df = pd.read_pickle(os.path.join(scratch_dir, trans_name+'_null_prePts.pkl')) # Calculate DistSeg, Dist_MHWbay, DistSegDH, DistSegDL, DistSegArm, and sort points (SplitSort) pts_df = fun.join_columns(pts_df, trans_df, tID_fld) pts_df = fun.prep_points(pts_df, tID_fld, pID_fld, sitevals['MHW'], fill) # Aggregate ptZmhw to max and mean and join to transects pts_df, zmhw = fun.aggregate_z(pts_df, sitevals['MHW'], tID_fld, 'ptZ', fill) trans_df = fun.join_columns(trans_df, zmhw) # Join transect values to pts pts_df = fun.join_columns(pts_df, trans_df, tID_fld) # pID_fld needs to be among the columns if not pID_fld in pts_df.columns: pts_df.reset_index(drop=False, inplace=True) # Match field names to those in sorted_pt_flds list for fld in pts_df.columns: if fld not in sorted_pt_flds: for i, fldi in enumerate(sorted_pt_flds): if fldi.lower() == fld.lower(): sorted_pt_flds[i] = fld print(fld) # Drop extra fields and sort columns trans_df.drop(extra_fields, axis=1, inplace=True, errors='ignore') for i, f in enumerate(sorted_pt_flds): for c in pts_df.columns: if f.lower() == c.lower(): sorted_pt_flds[i] = c pts_df = pts_df.reindex_axis(sorted_pt_flds, axis=1) # convert projected coordinates to geographic coordinates (lat, lon in NAD83) pts_df = fun.add_latlon(pts_df, proj_code) # Save dataframes trans_df.to_pickle(os.path.join(scratch_dir, trans_name+'_null.pkl')) pts_df.to_pickle(os.path.join(scratch_dir, pts_name+'_null.pkl')) # View random rows from the points DF pts_df.loc[:,['SplitSort', 'seg_x', 'SubType', 'ptZmhw', 'sort_ID', 'Dist_Seg', 'mean_Zmhw']].sample(10) ###Output _____no_output_____ ###Markdown Change number of significant digits- Elevations: 2 significant digits - Lengths: 1 (lidar has 15-30 cm resolution in vertical and 1-m-ish in horizontal I believe)- UTM coords: 2- lat longs: 6- LRR: 2Would be nice if fill value was always integer (not -99999.0 etc.) ###Code # Replace NaNs with fill value pts_df.fillna(fill, inplace=True) # Round fields to given significant digits fprecision = {# UTM coordinates 'seg_x':2, 'seg_y':2, 'SL_x':2, 'SL_y':2, 'DL_x':2, 'DL_y':2, 'DH_x':2, 'DH_y':2, 'DL_snapX':2, 'DL_snapY':2, 'DH_snapX':2, 'DH_snapY':2, 'Arm_x':2, 'Arm_y':2, # Geographic coordinates 'seg_lon':6, 'seg_lat':6, # Elevations 'ptZ':2, 'ptZmhw':2, 'DL_z':2, 'DL_zmhw':2, 'DH_z':2, 'DH_zmhw':2, 'Arm_z':2, 'Arm_zmhw':2, 'uBH':2, 'mean_Zmhw':2, 'max_Zmhw':2, # Lengths 'Dist_Seg':1, 'Dist_MHWbay':1, 'DistSegDH':1, 'DistSegDL':1, 'DistSegArm':1, 'DistDH':1, 'DistDL':1, 'DistArm':1,'Dist2Inlet':1, 'WidthPart':1, 'WidthLand':1, 'WidthFull':1, 'uBW':1, # LRR 'LRR':2, # IDs 'SplitSort':0, 'sort_ID':0, 'TRANSECTID':0, 'TRANSORDER':0, 'DD_ID':0, # Other 'Azimuth':1,'Bslope':4,'ptSlp':4} pts_df = pts_df.round(fprecision) # # Set GeoSet, SubType, VegDens, VegType fields to int32 dtypes pts_df = pts_df.astype({'GeoSet':'int32', 'SubType':'int32', 'VegDens':'int32', 'VegType':'int32', 'Construction':'int32', 'Development':'int32', 'Nourishment':'int32', 'sort_ID':'int32', 'DD_ID':'int32', 'TRANSECTID':'int32'}) # Recode pts_df.to_pickle(os.path.join(scratch_dir, pts_name+'_fill_ints.pkl')) # View random rows from the points DF pts_df.loc[:,['SplitSort', 'sort_ID', 'seg_y', 'VegType', 'ptSlp', 'Dist_Seg', 'max_Zmhw', 'Development', 'TRANSECTID']].sample(10) ###Output _____no_output_____ ###Markdown Recode the values for CSV output and model running ###Code # Recode pts_df4csv = pts_df.replace({'SubType': {7777:'{1111, 2222}', 1000:'{1111, 3333}'}, 'VegType': {77:'{11, 22}', 88:'{22, 33}', 99:'{33, 44}'}, 'VegDens': {666: '{111, 222}', 777: '{222, 333}', 888: '{333, 444}', 999: '{222, 333, 444}'}}) # Save and view sample pts_df4csv.to_pickle(os.path.join(scratch_dir, pts_name+'_csv.pkl')) pts_df.loc[:,['SplitSort', 'sort_ID', 'VegType', 'SubType', 'VegDens', 'GeoSet']].sample(10) # Replace fills with Nulls pts_df = pts_df.replace(fill, np.nan) pts_df.to_pickle(os.path.join(scratch_dir, pts_name+'_null.pkl')) ###Output _____no_output_____ ###Markdown Quality checkingLook at extracted profiles from around the island. Enter the transect ID within the available range when prompted. Evaluate the plots for consistency among variables. Repeat various times until you can be satisfied that the variables are consistent with each other and appear to represent reality. View areas with inconsistencies in a GIS. ###Code desccols = ['DL_zmhw', 'DH_zmhw', 'Arm_zmhw', 'uBW', 'uBH', 'Dist2Inlet', 'WidthPart', 'WidthLand', 'WidthFull', 'mean_Zmhw', 'max_Zmhw'] # Histograms trans_df.hist(desccols, sharey=True, figsize=[15, 10], bins=20) plt.show() plt.close('all') flds_dist = ['SplitSort', 'Dist_Seg', 'Dist_MHWbay', 'DistSegDH', 'DistSegDL', 'DistSegArm'] flds_z = ['ptZmhw', 'ptZ', 'ptSlp'] pts_df.loc[:,flds_dist+flds_z].describe() pts_df.hist(flds_dist, sharey=True, figsize=[15, 8], layout=(2,3)) pts_df.hist(flds_z, sharey=True, figsize=[15, 4], layout=(1,3)) plt.show() plt.close('all') # Prompt for transect identifier (sort_ID) and get all points from that transect. trans_in = int(input('Transect ID ("sort_ID" {:d}-{:d}): '.format(int(pts_df[tID_fld].head(1)), int(pts_df[tID_fld].tail(1))))) pts_set = pts_df[pts_df[tID_fld] == trans_in] # Plot fig = plt.figure(figsize=(13,10)) # Plot the width of the island. ax1 = fig.add_subplot(211) try: fun.plot_island_profile(ax1, pts_set, sitevals['MHW'], sitevals['MTL']) except TypeError as err: print('TypeError: {}'.format(err)) pass # Zoom in on the upper beach. ax2 = fig.add_subplot(212) try: fun.plot_beach_profile(ax2, pts_set, sitevals['MHW'], sitevals['MTL'], maxDH) except TypeError as err: print('TypeError: {}'.format(err)) pass # Display plt.show() plt.close('all') ###Output Transect ID ("sort_ID" 1-1229): 1200 ###Markdown Report field values ###Code # Load dataframe pts_df4csv = pd.read_pickle(os.path.join(scratch_dir, pts_name+'_csv.pkl')) xmlfile = os.path.join(scratch_dir, pts_name+'_eainfo.xml') fun.report_fc_values(pts_df4csv, field_defs, xmlfile) ###Output Number of points in dataset: (278037, 56) SplitSort______________________________0 | 278036______________ No fills_________No nulls seg_x__________________________464797.51 | 491897.45___________ Fills present____No nulls seg_y_________________________4189227.39 | 4241883.85__________ Fills present____No nulls seg_lon_______________________-75.400256 | -75.092695__________ Fills present____No nulls seg_lat________________________37.849861 | 38.325035___________ Fills present____No nulls Dist_Seg_____________________________0.0 | 4097.4______________ Fills present____No nulls Dist_MHWbay______________________-3888.1 | 3831.4______________ Fills present____No nulls DistSegDH_________________________-379.2 | 4061.4______________ Fills present____No nulls DistSegDL_________________________-244.5 | 4082.7______________ Fills present____No nulls DistSegArm________________________-99999 | -99999______________ ONLY Fills_______No nulls ptZ________________________________-1.52 | 15.12_______________ Fills present____No nulls ptSlp______________________________0.001 | 73.2456_____________ Fills present____No nulls ptZmhw_____________________________-1.86 | 14.78_______________ Fills present____No nulls GeoSet.............. -99999 | 1 | 2 | 3 | 4 | 5 | 6 | 7 SubType............. -99999 | 3333 | 4444 | 6666 | {1111, 2222} | {1111, 3333} VegDens............. -99999 | 111 | 555 | {111, 222} | {333, 444} VegType............. -99999 | 11 | 55 | {11, 22} | {22, 33} | {33, 44} sort_ID________________________________1 | 1229________________ No fills_________No nulls TRANSECTID____________________________99 | 2430________________ Fills present____No nulls DD_ID_____________________________210001 | 211229______________ No fills_________No nulls Azimuth_____________________________27.8 | 321.0_______________ No fills_________No nulls LRR________________________________-6.24 | 21.49_______________ Fills present____No nulls SL_x___________________________464867.68 | 491897.57___________ Fills present____No nulls SL_y__________________________4189227.39 | 4241661.22__________ Fills present____No nulls Bslope_____________________________-0.21 | -0.0104_____________ Fills present____No nulls DL_x___________________________465288.62 | 491816.11___________ Fills present____No nulls DL_y__________________________4189290.48 | 4241695.01__________ Fills present____No nulls DL_z________________________________1.02 | 4.32________________ Fills present____No nulls DL_zmhw_____________________________0.68 | 3.98________________ Fills present____No nulls DL_snapX_______________________465282.66 | 491815.98___________ Fills present____No nulls DL_snapY______________________4189292.32 | 4241694.69__________ Fills present____No nulls DH_x___________________________464812.56 | 491806.33___________ Fills present____No nulls DH_y__________________________4189318.45 | 4241700.58__________ Fills present____No nulls DH_z________________________________1.03 | 7.95________________ Fills present____No nulls DH_zmhw_____________________________0.69 | 7.61________________ Fills present____No nulls DH_snapX_______________________464813.72 | 491805.65___________ Fills present____No nulls DH_snapY______________________4189319.22 | 4241698.93__________ Fills present____No nulls Arm_x_____________________________-99999 | -99999______________ ONLY Fills_______No nulls Arm_y_____________________________-99999 | -99999______________ ONLY Fills_______No nulls Arm_z_____________________________-99999 | -99999______________ ONLY Fills_______No nulls Arm_zmhw__________________________-99999 | -99999______________ ONLY Fills_______No nulls DistDH______________________________16.5 | 380.4_______________ Fills present____No nulls DistDL_______________________________2.4 | 377.1_______________ Fills present____No nulls DistArm___________________________-99999 | -99999______________ ONLY Fills_______No nulls Dist2Inlet___________________________3.6 | 31423.2_____________ Fills present____No nulls WidthPart___________________________39.2 | 3831.4______________ Fills present____No nulls WidthLand___________________________39.2 | 3985.8______________ Fills present____No nulls WidthFull___________________________39.2 | 6077.4______________ Fills present____No nulls uBW__________________________________2.4 | 380.4_______________ Fills present____No nulls uBH_________________________________0.68 | 3.98________________ Fills present____No nulls ub_feat............. -99999 | DH | DL mean_Zmhw__________________________-0.01 | 2.18________________ Fills present____No nulls max_Zmhw____________________________0.68 | 14.78_______________ Fills present____No nulls Construction........ 111 | 222 | 333 Development......... 111 | 222 | 333 Nourishment......... 111 | 222 | 333 ###Markdown Outputs Transect-averagedOutput the transect-averaged metrics in the following formats:- transects, unpopulated except for ID values, as gdb feature class- transects, unpopulated except for ID values, as shapefile- populated transects with fill values as gdb feature class- populated transects with null values as gdb feature class- populated transects with fill values as shapefile- raster of beach width (__uBW__) by transect ###Code # Load the dataframe trans_df = pd.read_pickle(os.path.join(scratch_dir, trans_name+'_null.pkl')) ###Output _____no_output_____ ###Markdown Vector format ###Code # Create transect file with only ID values and geometry to publish. trans_flds = ['TRANSECTID', 'DD_ID', 'MHW'] for i, f in enumerate(trans_flds): for c in trans_df.columns: if f.lower() == c.lower(): trans_flds[i] = c trans_4pub = fwa.JoinDFtoFC(trans_df.loc[:,trans_flds], extendedTrans, tID_fld, out_fc=sitevals['code']+'_trans') out_shp = arcpy.FeatureClassToFeatureClass_conversion(trans_4pub, scratch_dir, sitevals['code']+'_trans.shp') print("OUTPUT: {} in specified scratch_dir.".format(os.path.basename(str(out_shp)))) trans_4pubdf = fwa.FCtoDF(trans_4pub) xmlfile = os.path.join(scratch_dir, trans_4pub + '_eainfo.xml') trans_df_extra_flds = fun.report_fc_values(trans_4pubdf, field_defs, xmlfile) # Create transect FC with fill values - Join values from trans_df to the transect FC as a new file. trans_fc = fwa.JoinDFtoFC_2(trans_df, extendedTrans, tID_fld, out_fc=trans_name+'_fill') # Create transect FC with null values fwa.CopyFCandReplaceValues(trans_fc, fill, None, out_fc=trans_name+'_null', out_dir=home) # Save final transect SHP with fill values out_shp = arcpy.FeatureClassToFeatureClass_conversion(trans_fc, scratch_dir, trans_name+'_shp.shp') print("OUTPUT: {} in specified scratch_dir.".format(os.path.basename(str(out_shp)))) ###Output Created asis14_trans_fill from input dataframe and extTrans file. OUTPUT: asis14_trans_null OUTPUT: asis14_trans_shp.shp in specified scratch_dir. ###Markdown Raster - beach widthIt may be necessary to close any Arc sessions you have open. ###Code # Create a template raster corresponding to the transects. if not arcpy.Exists(rst_transID): print("{} was not found so we will create the base raster.".format(os.path.basename(rst_transID))) outEucAll = arcpy.sa.EucAllocation(extTrans_tidy, maximum_distance=50, cell_size=cell_size, source_field=tID_fld) outEucAll.save(os.path.basename(rst_transID)) # Create raster of uBW values by joining trans_df to the template raster. out_rst = fwa.JoinDFtoRaster(trans_df, os.path.basename(rst_transID), bw_rst, fill, tID_fld, 'uBW') ###Output OUTPUT: asis14_ubw. Field "Value" is ID and "uBW" is beachwidth. ###Markdown 5-m pointsOutput the point metrics in the following formats:- tabular, in CSV- populated points with fill values as gdb feature class- populated points with null values as gdb feature class- populated points with fill values as shapefile ###Code # Load the saved dataframes pts_df4csv = pd.read_pickle(os.path.join(scratch_dir, pts_name+'_csv.pkl')) pts_df = pd.read_pickle(os.path.join(scratch_dir, pts_name+'_null.pkl')) ###Output _____no_output_____ ###Markdown Tabular format ###Code # Save CSV in scratch_dir csv_fname = os.path.join(scratch_dir, pts_name +'.csv') pts_df4csv.to_csv(csv_fname, na_rep=fill, index=False) sz_mb = os.stat(csv_fname).st_size/(1024.0 * 1024.0) print("\nOUTPUT: {} (size: {:.2f} MB) in specified scratch_dir.".format(os.path.basename(csv_fname), sz_mb)) ###Output OUTPUT: asis14_pts.csv (size: 107.61 MB) in specified scratch_dir. ###Markdown Vector format ###Code # Convert pts_df to FC - automatically converts NaNs to fills (default fill is -99999) pts_fc = fwa.DFtoFC_large(pts_df, out_fc=os.path.join(arcpy.env.workspace, pts_name+'_fill'), spatial_ref=utmSR, df_id=pID_fld, xy=["seg_x", "seg_y"]) # Save final FCs with null values fwa.CopyFCandReplaceValues(pts_fc, fill, None, out_fc=pts_name+'_null', out_dir=home) # Save final points as SHP with fill values out_pts_shp = arcpy.FeatureClassToFeatureClass_conversion(pts_fc, scratch_dir, pts_name+'_shp.shp') print("OUTPUT: {} in specified scratch_dir.".format(os.path.basename(str(out_pts_shp)))) ###Output Converting points DF to FC... ... converting dataframe to array... ... converting array to feature class... OUTPUT: asis14_pts_fill Duration: 0:31:8.2 seconds OUTPUT: asis14_pts_null OUTPUT: asis14_pts_shp.shp in specified scratch_dir.
IMDB_and_Amazon_Review_Classification_with_SpaCy.ipynb
###Markdown 1) Importing the datasets ###Code import numpy as np import pandas as pd import matplotlib.pyplot as plt import spacy nlp = spacy.load('en_core_web_sm') data_yelp = pd.read_csv('/content/yelp_labelled.txt', sep='\t',header=None) data_yelp.head() # review and sentiment # 0-Negative, 1-Positive for positive review # Assign column names columan_name = ['Review', 'Sentiment'] data_yelp.columns = columan_name data_yelp.head() data_yelp.shape # 1000 rows (reviews), 2 columns (Sentiments) data_amazon = pd.read_csv('/content/amazon_cells_labelled.txt',sep='\t',header=None) data_amazon.head() # review and sentiment # 0-Negative, 1-Positive for positive review data_amazon.columns = columan_name data_amazon.head() data_amazon.shape data_imdb = pd.read_csv('/content/imdb_labelled.txt',sep='\t',header=None) data_imdb.head() data_imdb.columns = columan_name data_imdb.head() data_imdb.shape # Append all the data in a single dataframe data = data_yelp.append([data_amazon, data_imdb],ignore_index=True) data.shape data.head() # check distribution of sentiments data['Sentiment'].value_counts() # 1346 positive reviews # 1362 Negative reviews # check for null values data.isnull().sum() # no null values in the data x = data['Review'] y = data['Sentiment'] ###Output _____no_output_____ ###Markdown 2) Data Cleaning ###Code # here we will remove stopwords, punctuations # as well as we will apply lemmatization ###Output _____no_output_____ ###Markdown Create a function to clean the data ###Code import string punct = string.punctuation punct from spacy.lang.en.stop_words import STOP_WORDS stopwords = list(STOP_WORDS) # list of stopwords # creating a function for data cleaning def text_data_cleaning(sentence): doc = nlp(sentence) tokens = [] # list of tokens for token in doc: if token.lemma_ != "-PRON-": temp = token.lemma_.lower().strip() else: temp = token.lower_ tokens.append(temp) cleaned_tokens = [] for token in tokens: if token not in stopwords and token not in punct: cleaned_tokens.append(token) return cleaned_tokens # if root form of that word is not pronoun then it is going to convert that into lower form # and if that word is a proper noun, then we are directly taking lower form, because there is no lemma for proper noun text_data_cleaning("Hello all, It's a beautiful day outside there!") # stopwords and punctuations removed ###Output _____no_output_____ ###Markdown Vectorization Feature Engineering (TF-IDF) ###Code from sklearn.svm import LinearSVC from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.pipeline import Pipeline tfidf = TfidfVectorizer(tokenizer=text_data_cleaning) # tokenizer=text_data_cleaning, tokenization will be done according to this function classifier = LinearSVC() ###Output _____no_output_____ ###Markdown 3) Train the model Splitting the dataset into the Train and Test set ###Code from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.2, random_state = 0) x_train.shape, x_test.shape # 2198 samples in training dataset and 550 in test dataset x_train.head() ###Output _____no_output_____ ###Markdown Fit the x_train and y_train ###Code clf = Pipeline([('tfidf',tfidf), ('clf',classifier)]) # it will first do vectorization and then it will do classification clf.fit(x_train, y_train) # in this we don't need to prepare the dataset for testing(x_test) ###Output _____no_output_____ ###Markdown 4) Predict the Test set results ###Code from sklearn.metrics import accuracy_score, classification_report, confusion_matrix y_pred = clf.predict(x_test) # confusion_matrix confusion_matrix(y_test, y_pred) # classification_report print(classification_report(y_test, y_pred)) # we are getting almost 77% accuracy accuracy_score(y_test, y_pred) # 76% accuracy clf.predict(["Wow, I am learning Natural Language Processing in fun fashion!"]) # output is 1, that means review is positive clf.predict(["It's hard to learn new things!"]) # output is 0, that means review is Negative ###Output _____no_output_____
correction_factor_maps.ipynb
###Markdown South Africa ###Code shpZAF = geopandas.read_file(data_path + '/country_shapefiles/ZAF/zaf_admbnda_adm1_2016SADB_OCHA.shp') cfEg2_ZAF = xr.open_dataarray(results_path + '/ZAF/cf_ERA_GWA2.nc') cfEg3_ZAF = xr.open_dataarray(results_path + '/ZAF/cf_ERA_GWA3.nc') cfMg2_ZAF = xr.open_dataarray(results_path + '/ZAF/cf_MERRA_GWA2.nc') cfMg3_ZAF = xr.open_dataarray(results_path + '/ZAF/cf_MERRA_GWA3.nc') max(cfEg2_ZAF.max().values,cfMg2_ZAF.max().values,cfEg3_ZAF.max().values,cfMg3_ZAF.max().values) data = [cfEg2_ZAF,cfEg3_ZAF,cfMg2_ZAF,cfMg3_ZAF] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(2, 2,figsize=(8,5.4),gridspec_kw = {'hspace':0.5}) for i in range(4): axes[int(i/2),i%2].set_xlim(16,32.5) axes[int(i/2),i%2].set_ylim(-35,-22) data[i].plot.imshow(ax=axes[int(i/2),i%2],vmin=0, vmax=2) shpZAF.boundary.plot(ax=axes[int(i/2),i%2],color='lightgray',linewidth=0.8) axes[int(i/2),i%2].set_title(titles[i]) axes[int(i/2),i%2].set_xlabel('Longitude') axes[int(i/2),i%2].set_ylabel('Latitude') plt.savefig(results_path + '/plots/cf_ZAF.png',dpi=300) plt.boxplot(pd.Series(cfEg2_ZAF.values.flatten()).dropna()) fig,ax = plt.subplots(figsize=(10,5)) ax.set_xlim(16,32.5) ax.set_ylim(-35,-22) cfEg2_ZAF.plot.imshow(ax=ax) shpZAF.boundary.plot(ax=ax,color='lightgray',linewidth=0.8) ###Output _____no_output_____ ###Markdown New Zealand ###Code shpNZ = geopandas.read_file(data_path + '/country_shapefiles/NZ/CON2017_HD_Clipped.shp') cfEg2_NZ = xr.open_dataarray(results_path + '/NZ/cf_ERA_GWA2.nc') cfEg3_NZ = xr.open_dataarray(results_path + '/NZ/cf_ERA_GWA3.nc') cfMg2_NZ = xr.open_dataarray(results_path + '/NZ/cf_MERRA_GWA2.nc') cfMg3_NZ = xr.open_dataarray(results_path + '/NZ/cf_MERRA_GWA3.nc') max(cfEg2_NZ.max().values,cfMg2_NZ.max().values,cfEg3_NZ.max().values,cfMg3_NZ.max().values) data = [cfEg2_NZ,cfEg3_NZ,cfMg2_NZ,cfMg3_NZ] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(2, 2,figsize=(8,7),gridspec_kw = {'hspace':0.5}) for i in range(4): axes[int(i/2),i%2].set_xlim(166,178) axes[int(i/2),i%2].set_ylim(-34,-48) try: data[i].sel(longitude=slice(160,180),latitude=slice(-34,-48)).plot.imshow(ax=axes[int(i/2),i%2],vmin=0,vmax=3) except: data[i].sel(lon=slice(160,180),lat=slice(-34,-48)).plot.imshow(ax=axes[int(i/2),i%2],vmin=0,vmax=3) shpNZ.to_crs({'init': 'epsg:4326'}).boundary.plot(ax=axes[int(i/2),i%2],color='lightgray',linewidth=0.4) axes[int(i/2),i%2].set_title(titles[i]) axes[int(i/2),i%2].set_xlabel('Longitude') axes[int(i/2),i%2].set_ylabel('Latitude') plt.savefig(results_path + '/plots/cf_NZ.png',dpi=300) data = [cfEg2_NZ,cfEg3_NZ,cfMg2_NZ,cfMg3_NZ] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(1, 4,figsize=(40,8),gridspec_kw = {'wspace':0.1}) for i in range(4): data[i].plot.imshow(ax=axes[i]) axes[i].set_title(titles[i]) ###Output _____no_output_____ ###Markdown Brazil ###Code shpBRA = geopandas.read_file(data_path + '/country_shapefiles/BRA/BRA_adm1.shp') cfEg2_BRA = xr.open_dataarray(results_path + '/BRA/cf_ERA_GWA2.nc') cfEg3_BRA = xr.open_dataarray(results_path + '/BRA/cf_ERA_GWA3.nc') cfMg2_BRA = xr.open_dataarray(results_path + '/BRA/cf_MERRA_GWA2.nc') cfMg3_BRA = xr.open_dataarray(results_path + '/BRA/cf_MERRA_GWA3.nc') max(cfEg2_BRA.max().values,cfMg2_BRA.max().values,cfEg3_BRA.max().values,cfMg3_BRA.max().values) data = [cfEg2_BRA,cfEg3_BRA,cfMg2_BRA,cfMg3_BRA] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(2, 2,figsize=(9,5.4),gridspec_kw = {'wspace':0.1,'hspace':0.6}) for i in range(4): axes[int(i/2),i%2].set_xlim(-75,-30) axes[int(i/2),i%2].set_ylim(-25,5) data[i].plot.imshow(ax=axes[int(i/2),i%2],norm=matplotlib.colors.PowerNorm(gamma=0.5),vmin=0,vmax=19) shpBRA.boundary.plot(ax=axes[int(i/2),i%2],color='lightgray',linewidth=0.8) axes[int(i/2),i%2].set_title(titles[i]) axes[int(i/2),i%2].set_xlabel('longitude') axes[int(i/2),i%2].set_ylabel('latitude') plt.savefig(results_path + '/plots/cf_BRA.png') data = [cfEg2_BRA,cfEg3_BRA,cfMg2_BRA,cfMg3_BRA] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(2, 2,figsize=(9,5.4),gridspec_kw = {'wspace':0.1,'hspace':0.6}) for i in range(4): axes[int(i/2),i%2].set_xlim(-75,-30) axes[int(i/2),i%2].set_ylim(-25,5) data[i].plot.imshow(ax=axes[int(i/2),i%2],vmin=0,vmax=2) shpBRA.boundary.plot(ax=axes[int(i/2),i%2],color='lightgray',linewidth=0.8) axes[int(i/2),i%2].set_title(titles[i]) axes[int(i/2),i%2].set_xlabel('Longitude') axes[int(i/2),i%2].set_ylabel('Latitude') plt.savefig(results_path + '/plots/cf_BRA.png',dpi=300) data = [cfEg2_BRA,cfEg3_BRA,cfMg2_BRA,cfMg3_BRA] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(1, 4,figsize=(18,2.7),gridspec_kw = {'wspace':0.25}) for i in range(4): axes[i].set_xlim(-75,-30) axes[i].set_ylim(-25,5) data[i].plot.imshow(ax=axes[i]) shpBRA.boundary.plot(ax=axes[i],color='lightgray',linewidth=0.8) axes[i].set_title(titles[i]) plt.savefig(results_path + '/plots/cf_BRA.png') fig, axes = plt.subplots(1, 4,figsize=(40,8),gridspec_kw = {'wspace':0.1}) for i in range(4): data[i].plot.imshow(ax=axes[i]) axes[i].set_title(titles[i]) ###Output _____no_output_____ ###Markdown USA ###Code shpUSA = geopandas.read_file(data_path + '/country_shapefiles/USA/cb_2018_us_state_500k.shp') cfEg2_USA = xr.open_dataarray(results_path + '/USA/cf_ERA_GWA2.nc') cfEg3_USA = xr.open_dataarray(results_path + '/USA/cf_ERA_GWA3.nc') cfMg2_USA = xr.open_dataarray(results_path + '/USA/cf_MERRA_GWA2.nc') cfMg3_USA = xr.open_dataarray(results_path + '/USA/cf_MERRA_GWA3.nc') max(cfEg2_USA.max().values,cfMg2_USA.max().values,cfEg3_USA.max().values,cfMg3_USA.max().values) data = [cfEg2_USA,cfEg3_USA,cfMg2_USA,cfMg3_USA] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(1, 4,figsize=(18,2.7),gridspec_kw = {'wspace':0.25}) for i in range(4): axes[i].set_xlim(-125,-67) axes[i].set_ylim(25,50) data[i].plot.imshow(ax=axes[i]) shpUSA.boundary.plot(ax=axes[i],color='lightgray',linewidth=0.8) axes[i].set_title(titles[i]) data = [cfEg2_USA,cfEg3_USA,cfMg2_USA,cfMg3_USA] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(2, 2,figsize=(13,5.4),gridspec_kw = {'wspace':0.15,'hspace':0.5}) for i in range(4): axes[int(i/2),i%2].set_xlim(-125,-67) axes[int(i/2),i%2].set_ylim(25,50) data[i].plot.imshow(ax=axes[int(i/2),i%2]) shpUSA.boundary.plot(ax=axes[int(i/2),i%2],color='lightgray',linewidth=0.8) axes[int(i/2),i%2].set_title(titles[i]) plt.savefig(results_path + '/plots/cf_USA.png') data = [cfEg2_USA,cfEg3_USA,cfMg2_USA,cfMg3_USA] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(2, 2,figsize=(13,5.4),gridspec_kw = {'wspace':0.15,'hspace':0.5}) for i in range(4): axes[int(i/2),i%2].set_xlim(-125,-67) axes[int(i/2),i%2].set_ylim(25,50) data[i].plot.imshow(ax=axes[int(i/2),i%2],norm=matplotlib.colors.PowerNorm(gamma=0.5),vmin=0,vmax=13) shpUSA.boundary.plot(ax=axes[int(i/2),i%2],color='lightgray',linewidth=0.8) axes[int(i/2),i%2].set_title(titles[i]) axes[int(i/2),i%2].set_xlabel('longitude') axes[int(i/2),i%2].set_ylabel('latitude') plt.savefig(results_path + '/plots/cf_USA.png') data = [cfEg2_USA,cfEg3_USA,cfMg2_USA,cfMg3_USA] titles = ['ERA5 GWA2','ERA5 GWA3','MERRA-2 GWA2','MERRA-2 GWA3'] fig, axes = plt.subplots(2, 2,figsize=(13,5.4),gridspec_kw = {'wspace':0.15,'hspace':0.5}) for i in range(4): axes[int(i/2),i%2].set_xlim(-125,-67) axes[int(i/2),i%2].set_ylim(25,50) data[i].plot.imshow(ax=axes[int(i/2),i%2],vmin=0,vmax=2) shpUSA.boundary.plot(ax=axes[int(i/2),i%2],color='lightgray',linewidth=0.8) axes[int(i/2),i%2].set_title(titles[i]) axes[int(i/2),i%2].set_xlabel('Longitude') axes[int(i/2),i%2].set_ylabel('Latitude') plt.savefig(results_path + '/plots/cf_USA.png',dpi=300) fig, axes = plt.subplots(1, 4,figsize=(40,8),gridspec_kw = {'wspace':0.1}) for i in range(4): data[i].plot.imshow(ax=axes[i]) axes[i].set_title(titles[i]) ###Output _____no_output_____ ###Markdown compare GWA2 and GWA3 cfs ###Code def dif_g2_g3(gwa2,gwa3,ds): if ds=='E': gwa3ig2 = gwa3.interp(longitude = gwa2.longitude.values, latitude = gwa2.latitude.values, method='nearest') else: gwa3ig2 = gwa3.interp(lon = gwa2.lon.values, lat = gwa2.lat.values, method='nearest') difg2g3 = (gwa3ig2-gwa2).values.flatten() return(difg2g3[~np.isnan(difg2g3)]) def plot_difcf_country(Egwa2,Egwa3,Mgwa2,Mgwa3,ax,title): difE = dif_g2_g3(Egwa2,Egwa3,'E') difM = dif_g2_g3(Mgwa2,Mgwa3,'M') difs = pd.DataFrame({'Dataset':['ERA5']*len(difE) + ['MERRA-2']*len(difM), 'correction factor GWA3 - correction factor GWA2':np.append(difE,difM)}) sns.boxplot(x='Dataset',y='correction factor GWA3 - correction factor GWA2',data=difs,ax=ax) ax.set_title(title) fig, axes = plt.subplots(1, 4,figsize=(12,6),gridspec_kw = {'wspace':0.5}) plot_difcf_country(cfEg2_USA,cfEg3_USA,cfMg2_USA,cfMg3_USA,axes[0],'USA') plot_difcf_country(cfEg2_BRA,cfEg3_BRA,cfMg2_BRA,cfMg3_BRA,axes[1],'Brazil') plot_difcf_country(cfEg2_NZ,cfEg3_NZ,cfMg2_NZ,cfMg3_NZ,axes[2],'New Zealand') plot_difcf_country(cfEg2_ZAF,cfEg3_ZAF,cfMg2_ZAF,cfMg3_ZAF,axes[3],'South Africa') plt.savefig(results_path + '/plots/cf_MBE_GWA2_GWA3.png') ###Output _____no_output_____
00-gpu-testing-examples/mnist_sample_example.ipynb
###Markdown Reference:* https://towardsdatascience.com/building-a-deep-learning-model-using-keras-1548ca149d37?gi=b9fc6d293b7* https://www.tensorflow.org/tutorials ###Code import tensorflow as tf from distutils.version import LooseVersion # Check TensorFlow Version assert LooseVersion(tf.__version__) >= LooseVersion('1.12'), 'Please use TensorFlow version 1.12 or newer' print('TensorFlow Version: {}'.format(tf.__version__)) # Check for a GPU if not tf.test.gpu_device_name(): warnings.warn('No GPU found. Please use a GPU to train your neural network.') else: print('Default GPU Device: {}'.format(tf.test.gpu_device_name())) mnist = tf.keras.datasets.mnist # Load mnist data set (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train[0,10] # convert the values from RGB integer to 0-1 range for better training x_train, x_test = x_train / 255.0, x_test / 255.0 x_train[0,10] from tensorflow.keras.models import Sequential from tensorflow.layers import Dense, Flatten, Dropout # use a FFT model from kera model = Sequential() model.add(Flatten(input_shape=(28, 28))) model.add(Dense(units=512, activation=tf.nn.relu)) model.add(Dropout(rate=0.2)) model.add(Dense(units=10, activation=tf.nn.softmax)) # model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) layers = model.layers # display object attributes # dir(layers[0]) print("Model:") print("input_shape, output_shape") for layer in layers: print(layer.input_shape,',',layer.output_shape) # use model summary function model.summary() model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, epochs=5) loss, accuracy = model.evaluate(x_test, y_test) print("validation accuracy: ", accuracy) test_list = list([1,2]) def max_list_index(l): ''' this function returns the index and value of the max element from the given list. example: test_list = [4, 3, 10] idx, value = max_list_index(test_list) idx = 2 # since the max element 10 has index 2 value = 10 # 10 is the max element from the given list ''' # print(test_list) # l.__getitem__(1) idx = max(range(len(l)), key=l.__getitem__ ) return idx, l[idx] idx, value = max_list_index(test_list) print("index of max element is:", idx) print("value of max element is:", value) import matplotlib.pyplot as plt # import matplotlib.image as mpimg import numpy as np %matplotlib inline # make slice so that it is a patch with one number # test_images = x_test[0:1] x_test_number = x_test.shape[0] image_index = np.random.randint(0, x_test_number) test_images = x_test[image_index:image_index + 1] test_images = (test_images * 255) #.astype(np.uint8) # print(test_images) print(test_images.shape) # show the first image from the batch test_images plt.imshow(test_images[0], cmap="gray", interpolation='nearest') # Make prediction pred_prob = model.predict(test_images) print(pred_prob.tolist()[0]) number, confidence = max_list_index(pred_prob.tolist()[0]) print("Predict as: ", number, " with conficdence: ", confidence) ###Output [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] Predict as: 1 with conficdence: 1.0
Sequence Models/Dinosaurus Island Character level language model final v3.ipynb
###Markdown Character level language model - Dinosaurus landWelcome to Dinosaurus Island! 65 million years ago, dinosaurs existed, and in this assignment they are back. You are in charge of a special task. Leading biology researchers are creating new breeds of dinosaurs and bringing them to life on earth, and your job is to give names to these dinosaurs. If a dinosaur does not like its name, it might go beserk, so choose wisely! Luckily you have learned some deep learning and you will use it to save the day. Your assistant has collected a list of all the dinosaur names they could find, and compiled them into this [dataset](dinos.txt). (Feel free to take a look by clicking the previous link.) To create new dinosaur names, you will build a character level language model to generate new names. Your algorithm will learn the different name patterns, and randomly generate new names. Hopefully this algorithm will keep you and your team safe from the dinosaurs' wrath! By completing this assignment you will learn:- How to store text data for processing using an RNN - How to synthesize data, by sampling predictions at each time step and passing it to the next RNN-cell unit- How to build a character-level text generation recurrent neural network- Why clipping the gradients is importantWe will begin by loading in some functions that we have provided for you in `rnn_utils`. Specifically, you have access to functions such as `rnn_forward` and `rnn_backward` which are equivalent to those you've implemented in the previous assignment. ###Code import numpy as np from utils import * import random ###Output _____no_output_____ ###Markdown 1 - Problem Statement 1.1 - Dataset and PreprocessingRun the following cell to read the dataset of dinosaur names, create a list of unique characters (such as a-z), and compute the dataset and vocabulary size. ###Code data = open('dinos.txt', 'r').read() data= data.lower() chars = list(set(data)) data_size, vocab_size = len(data), len(chars) print('There are %d total characters and %d unique characters in your data.' % (data_size, vocab_size)) ###Output There are 19909 total characters and 27 unique characters in your data. ###Markdown The characters are a-z (26 characters) plus the "\n" (or newline character), which in this assignment plays a role similar to the `` (or "End of sentence") token we had discussed in lecture, only here it indicates the end of the dinosaur name rather than the end of a sentence. In the cell below, we create a python dictionary (i.e., a hash table) to map each character to an index from 0-26. We also create a second python dictionary that maps each index back to the corresponding character character. This will help you figure out what index corresponds to what character in the probability distribution output of the softmax layer. Below, `char_to_ix` and `ix_to_char` are the python dictionaries. ###Code char_to_ix = { ch:i for i,ch in enumerate(sorted(chars)) } ix_to_char = { i:ch for i,ch in enumerate(sorted(chars)) } print(ix_to_char) ###Output {0: '\n', 1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z'} ###Markdown 1.2 - Overview of the modelYour model will have the following structure: - Initialize parameters - Run the optimization loop - Forward propagation to compute the loss function - Backward propagation to compute the gradients with respect to the loss function - Clip the gradients to avoid exploding gradients - Using the gradients, update your parameter with the gradient descent update rule.- Return the learned parameters **Figure 1**: Recurrent Neural Network, similar to what you had built in the previous notebook "Building a RNN - Step by Step". At each time-step, the RNN tries to predict what is the next character given the previous characters. The dataset $X = (x^{\langle 1 \rangle}, x^{\langle 2 \rangle}, ..., x^{\langle T_x \rangle})$ is a list of characters in the training set, while $Y = (y^{\langle 1 \rangle}, y^{\langle 2 \rangle}, ..., y^{\langle T_x \rangle})$ is such that at every time-step $t$, we have $y^{\langle t \rangle} = x^{\langle t+1 \rangle}$. 2 - Building blocks of the modelIn this part, you will build two important blocks of the overall model:- Gradient clipping: to avoid exploding gradients- Sampling: a technique used to generate charactersYou will then apply these two functions to build the model. 2.1 - Clipping the gradients in the optimization loopIn this section you will implement the `clip` function that you will call inside of your optimization loop. Recall that your overall loop structure usually consists of a forward pass, a cost computation, a backward pass, and a parameter update. Before updating the parameters, you will perform gradient clipping when needed to make sure that your gradients are not "exploding," meaning taking on overly large values. In the exercise below, you will implement a function `clip` that takes in a dictionary of gradients and returns a clipped version of gradients if needed. There are different ways to clip gradients; we will use a simple element-wise clipping procedure, in which every element of the gradient vector is clipped to lie between some range [-N, N]. More generally, you will provide a `maxValue` (say 10). In this example, if any component of the gradient vector is greater than 10, it would be set to 10; and if any component of the gradient vector is less than -10, it would be set to -10. If it is between -10 and 10, it is left alone. **Figure 2**: Visualization of gradient descent with and without gradient clipping, in a case where the network is running into slight "exploding gradient" problems. **Exercise**: Implement the function below to return the clipped gradients of your dictionary `gradients`. Your function takes in a maximum threshold and returns the clipped versions of your gradients. You can check out this [hint](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.clip.html) for examples of how to clip in numpy. You will need to use the argument `out = ...`. ###Code ### GRADED FUNCTION: clip def clip(gradients, maxValue): ''' Clips the gradients' values between minimum and maximum. Arguments: gradients -- a dictionary containing the gradients "dWaa", "dWax", "dWya", "db", "dby" maxValue -- everything above this number is set to this number, and everything less than -maxValue is set to -maxValue Returns: gradients -- a dictionary with the clipped gradients. ''' dWaa, dWax, dWya, db, dby = gradients['dWaa'], gradients['dWax'], gradients['dWya'], gradients['db'], gradients['dby'] ### START CODE HERE ### # clip to mitigate exploding gradients, loop over [dWax, dWaa, dWya, db, dby]. (≈2 lines) for gradient in [dWax, dWaa, dWya, db, dby]: gradient = np.clip(gradient,-maxValue,maxValue,out=gradient) ### END CODE HERE ### gradients = {"dWaa": dWaa, "dWax": dWax, "dWya": dWya, "db": db, "dby": dby} return gradients np.random.seed(3) dWax = np.random.randn(5,3)*10 dWaa = np.random.randn(5,5)*10 dWya = np.random.randn(2,5)*10 db = np.random.randn(5,1)*10 dby = np.random.randn(2,1)*10 gradients = {"dWax": dWax, "dWaa": dWaa, "dWya": dWya, "db": db, "dby": dby} gradients = clip(gradients, 10) print("gradients[\"dWaa\"][1][2] =", gradients["dWaa"][1][2]) print("gradients[\"dWax\"][3][1] =", gradients["dWax"][3][1]) print("gradients[\"dWya\"][1][2] =", gradients["dWya"][1][2]) print("gradients[\"db\"][4] =", gradients["db"][4]) print("gradients[\"dby\"][1] =", gradients["dby"][1]) ###Output gradients["dWaa"][1][2] = 10.0 gradients["dWax"][3][1] = -10.0 gradients["dWya"][1][2] = 0.29713815361 gradients["db"][4] = [ 10.] gradients["dby"][1] = [ 8.45833407] ###Markdown ** Expected output:** **gradients["dWaa"][1][2] ** 10.0 **gradients["dWax"][3][1]** -10.0 **gradients["dWya"][1][2]** 0.29713815361 **gradients["db"][4]** [ 10.] **gradients["dby"][1]** [ 8.45833407] 2.2 - SamplingNow assume that your model is trained. You would like to generate new text (characters). The process of generation is explained in the picture below: **Figure 3**: In this picture, we assume the model is already trained. We pass in $x^{\langle 1\rangle} = \vec{0}$ at the first time step, and have the network then sample one character at a time. **Exercise**: Implement the `sample` function below to sample characters. You need to carry out 4 steps:- **Step 1**: Pass the network the first "dummy" input $x^{\langle 1 \rangle} = \vec{0}$ (the vector of zeros). This is the default input before we've generated any characters. We also set $a^{\langle 0 \rangle} = \vec{0}$- **Step 2**: Run one step of forward propagation to get $a^{\langle 1 \rangle}$ and $\hat{y}^{\langle 1 \rangle}$. Here are the equations:$$ a^{\langle t+1 \rangle} = \tanh(W_{ax} x^{\langle t \rangle } + W_{aa} a^{\langle t \rangle } + b)\tag{1}$$$$ z^{\langle t + 1 \rangle } = W_{ya} a^{\langle t + 1 \rangle } + b_y \tag{2}$$$$ \hat{y}^{\langle t+1 \rangle } = softmax(z^{\langle t + 1 \rangle })\tag{3}$$Note that $\hat{y}^{\langle t+1 \rangle }$ is a (softmax) probability vector (its entries are between 0 and 1 and sum to 1). $\hat{y}^{\langle t+1 \rangle}_i$ represents the probability that the character indexed by "i" is the next character. We have provided a `softmax()` function that you can use.- **Step 3**: Carry out sampling: Pick the next character's index according to the probability distribution specified by $\hat{y}^{\langle t+1 \rangle }$. This means that if $\hat{y}^{\langle t+1 \rangle }_i = 0.16$, you will pick the index "i" with 16% probability. To implement it, you can use [`np.random.choice`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.random.choice.html).Here is an example of how to use `np.random.choice()`:```pythonnp.random.seed(0)p = np.array([0.1, 0.0, 0.7, 0.2])index = np.random.choice([0, 1, 2, 3], p = p.ravel())```This means that you will pick the `index` according to the distribution: $P(index = 0) = 0.1, P(index = 1) = 0.0, P(index = 2) = 0.7, P(index = 3) = 0.2$.- **Step 4**: The last step to implement in `sample()` is to overwrite the variable `x`, which currently stores $x^{\langle t \rangle }$, with the value of $x^{\langle t + 1 \rangle }$. You will represent $x^{\langle t + 1 \rangle }$ by creating a one-hot vector corresponding to the character you've chosen as your prediction. You will then forward propagate $x^{\langle t + 1 \rangle }$ in Step 1 and keep repeating the process until you get a "\n" character, indicating you've reached the end of the dinosaur name. ###Code # GRADED FUNCTION: sample def sample(parameters, char_to_ix, seed): """ Sample a sequence of characters according to a sequence of probability distributions output of the RNN Arguments: parameters -- python dictionary containing the parameters Waa, Wax, Wya, by, and b. char_to_ix -- python dictionary mapping each character to an index. seed -- used for grading purposes. Do not worry about it. Returns: indices -- a list of length n containing the indices of the sampled characters. """ # Retrieve parameters and relevant shapes from "parameters" dictionary Waa, Wax, Wya, by, b = parameters['Waa'], parameters['Wax'], parameters['Wya'], parameters['by'], parameters['b'] vocab_size = by.shape[0] n_a = Waa.shape[1] ### START CODE HERE ### # Step 1: Create the one-hot vector x for the first character (initializing the sequence generation). (≈1 line) x = np.zeros((vocab_size,1)) # Step 1': Initialize a_prev as zeros (≈1 line) a_prev = np.zeros((n_a,1)) # Create an empty list of indices, this is the list which will contain the list of indices of the characters to generate (≈1 line) indices = [] # Idx is a flag to detect a newline character, we initialize it to -1 idx = -1 # Loop over time-steps t. At each time-step, sample a character from a probability distribution and append # its index to "indices". We'll stop if we reach 50 characters (which should be very unlikely with a well # trained model), which helps debugging and prevents entering an infinite loop. counter = 0 newline_character = char_to_ix['\n'] while (idx != newline_character and counter != 50): # Step 2: Forward propagate x using the equations (1), (2) and (3) a = np.tanh(np.dot(Wax,x)+np.dot(Waa,a_prev)+b) z = np.dot(Wya,a)+by y = softmax(z) # for grading purposes np.random.seed(counter+seed) # Step 3: Sample the index of a character within the vocabulary from the probability distribution y idx = np.random.choice(list(range(vocab_size)), p=y.ravel()) # Append the index to "indices" indices.append(idx) # Step 4: Overwrite the input character as the one corresponding to the sampled index. x = np.zeros((vocab_size, 1)) x[idx] = 1 # Update "a_prev" to be "a" a_prev = a # for grading purposes seed += 1 counter +=1 ### END CODE HERE ### if (counter == 50): indices.append(char_to_ix['\n']) return indices np.random.seed(2) _, n_a = 20, 100 Wax, Waa, Wya = np.random.randn(n_a, vocab_size), np.random.randn(n_a, n_a), np.random.randn(vocab_size, n_a) b, by = np.random.randn(n_a, 1), np.random.randn(vocab_size, 1) parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "b": b, "by": by} indices = sample(parameters, char_to_ix, 0) print("Sampling:") print("list of sampled indices:", indices) print("list of sampled characters:", [ix_to_char[i] for i in indices]) ###Output Sampling: list of sampled indices: [12, 17, 24, 14, 13, 9, 10, 22, 24, 6, 13, 11, 12, 6, 21, 15, 21, 14, 3, 2, 1, 21, 18, 24, 7, 25, 6, 25, 18, 10, 16, 2, 3, 8, 15, 12, 11, 7, 1, 12, 10, 2, 7, 7, 11, 5, 6, 12, 25, 0, 0] list of sampled characters: ['l', 'q', 'x', 'n', 'm', 'i', 'j', 'v', 'x', 'f', 'm', 'k', 'l', 'f', 'u', 'o', 'u', 'n', 'c', 'b', 'a', 'u', 'r', 'x', 'g', 'y', 'f', 'y', 'r', 'j', 'p', 'b', 'c', 'h', 'o', 'l', 'k', 'g', 'a', 'l', 'j', 'b', 'g', 'g', 'k', 'e', 'f', 'l', 'y', '\n', '\n'] ###Markdown ** Expected output:** **list of sampled indices:** [12, 17, 24, 14, 13, 9, 10, 22, 24, 6, 13, 11, 12, 6, 21, 15, 21, 14, 3, 2, 1, 21, 18, 24, 7, 25, 6, 25, 18, 10, 16, 2, 3, 8, 15, 12, 11, 7, 1, 12, 10, 2, 7, 7, 11, 5, 6, 12, 25, 0, 0] **list of sampled characters:** ['l', 'q', 'x', 'n', 'm', 'i', 'j', 'v', 'x', 'f', 'm', 'k', 'l', 'f', 'u', 'o', 'u', 'n', 'c', 'b', 'a', 'u', 'r', 'x', 'g', 'y', 'f', 'y', 'r', 'j', 'p', 'b', 'c', 'h', 'o', 'l', 'k', 'g', 'a', 'l', 'j', 'b', 'g', 'g', 'k', 'e', 'f', 'l', 'y', '\n', '\n'] 3 - Building the language model It is time to build the character-level language model for text generation. 3.1 - Gradient descent In this section you will implement a function performing one step of stochastic gradient descent (with clipped gradients). You will go through the training examples one at a time, so the optimization algorithm will be stochastic gradient descent. As a reminder, here are the steps of a common optimization loop for an RNN:- Forward propagate through the RNN to compute the loss- Backward propagate through time to compute the gradients of the loss with respect to the parameters- Clip the gradients if necessary - Update your parameters using gradient descent **Exercise**: Implement this optimization process (one step of stochastic gradient descent). We provide you with the following functions: ```pythondef rnn_forward(X, Y, a_prev, parameters): """ Performs the forward propagation through the RNN and computes the cross-entropy loss. It returns the loss' value as well as a "cache" storing values to be used in the backpropagation.""" .... return loss, cache def rnn_backward(X, Y, parameters, cache): """ Performs the backward propagation through time to compute the gradients of the loss with respect to the parameters. It returns also all the hidden states.""" ... return gradients, adef update_parameters(parameters, gradients, learning_rate): """ Updates parameters using the Gradient Descent Update Rule.""" ... return parameters``` ###Code # GRADED FUNCTION: optimize def optimize(X, Y, a_prev, parameters, learning_rate = 0.01): """ Execute one step of the optimization to train the model. Arguments: X -- list of integers, where each integer is a number that maps to a character in the vocabulary. Y -- list of integers, exactly the same as X but shifted one index to the left. a_prev -- previous hidden state. parameters -- python dictionary containing: Wax -- Weight matrix multiplying the input, numpy array of shape (n_a, n_x) Waa -- Weight matrix multiplying the hidden state, numpy array of shape (n_a, n_a) Wya -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a) b -- Bias, numpy array of shape (n_a, 1) by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1) learning_rate -- learning rate for the model. Returns: loss -- value of the loss function (cross-entropy) gradients -- python dictionary containing: dWax -- Gradients of input-to-hidden weights, of shape (n_a, n_x) dWaa -- Gradients of hidden-to-hidden weights, of shape (n_a, n_a) dWya -- Gradients of hidden-to-output weights, of shape (n_y, n_a) db -- Gradients of bias vector, of shape (n_a, 1) dby -- Gradients of output bias vector, of shape (n_y, 1) a[len(X)-1] -- the last hidden state, of shape (n_a, 1) """ ### START CODE HERE ### # Forward propagate through time (≈1 line) loss, cache = rnn_forward(X,Y,a_prev,parameters) # Backpropagate through time (≈1 line) gradients, a = rnn_backward(X,Y,parameters,cache) # Clip your gradients between -5 (min) and 5 (max) (≈1 line) gradients = clip(gradients, 5) # Update parameters (≈1 line) parameters = update_parameters(parameters, gradients, learning_rate) ### END CODE HERE ### return loss, gradients, a[len(X)-1] np.random.seed(1) vocab_size, n_a = 27, 100 a_prev = np.random.randn(n_a, 1) Wax, Waa, Wya = np.random.randn(n_a, vocab_size), np.random.randn(n_a, n_a), np.random.randn(vocab_size, n_a) b, by = np.random.randn(n_a, 1), np.random.randn(vocab_size, 1) parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "b": b, "by": by} X = [12,3,5,11,22,3] Y = [4,14,11,22,25, 26] loss, gradients, a_last = optimize(X, Y, a_prev, parameters, learning_rate = 0.01) print("Loss =", loss) print("gradients[\"dWaa\"][1][2] =", gradients["dWaa"][1][2]) print("np.argmax(gradients[\"dWax\"]) =", np.argmax(gradients["dWax"])) print("gradients[\"dWya\"][1][2] =", gradients["dWya"][1][2]) print("gradients[\"db\"][4] =", gradients["db"][4]) print("gradients[\"dby\"][1] =", gradients["dby"][1]) print("a_last[4] =", a_last[4]) ###Output Loss = 126.503975722 gradients["dWaa"][1][2] = 0.194709315347 np.argmax(gradients["dWax"]) = 93 gradients["dWya"][1][2] = -0.007773876032 gradients["db"][4] = [-0.06809825] gradients["dby"][1] = [ 0.01538192] a_last[4] = [-1.] ###Markdown ** Expected output:** **Loss ** 126.503975722 **gradients["dWaa"][1][2]** 0.194709315347 **np.argmax(gradients["dWax"])** 93 **gradients["dWya"][1][2]** -0.007773876032 **gradients["db"][4]** [-0.06809825] **gradients["dby"][1]** [ 0.01538192] **a_last[4]** [-1.] 3.2 - Training the model Given the dataset of dinosaur names, we use each line of the dataset (one name) as one training example. Every 100 steps of stochastic gradient descent, you will sample 10 randomly chosen names to see how the algorithm is doing. Remember to shuffle the dataset, so that stochastic gradient descent visits the examples in random order. **Exercise**: Follow the instructions and implement `model()`. When `examples[index]` contains one dinosaur name (string), to create an example (X, Y), you can use this:```python index = j % len(examples) X = [None] + [char_to_ix[ch] for ch in examples[index]] Y = X[1:] + [char_to_ix["\n"]]```Note that we use: `index= j % len(examples)`, where `j = 1....num_iterations`, to make sure that `examples[index]` is always a valid statement (`index` is smaller than `len(examples)`).The first entry of `X` being `None` will be interpreted by `rnn_forward()` as setting $x^{\langle 0 \rangle} = \vec{0}$. Further, this ensures that `Y` is equal to `X` but shifted one step to the left, and with an additional "\n" appended to signify the end of the dinosaur name. ###Code # GRADED FUNCTION: model def model(data, ix_to_char, char_to_ix, num_iterations = 35000, n_a = 50, dino_names = 7, vocab_size = 27): """ Trains the model and generates dinosaur names. Arguments: data -- text corpus ix_to_char -- dictionary that maps the index to a character char_to_ix -- dictionary that maps a character to an index num_iterations -- number of iterations to train the model for n_a -- number of units of the RNN cell dino_names -- number of dinosaur names you want to sample at each iteration. vocab_size -- number of unique characters found in the text, size of the vocabulary Returns: parameters -- learned parameters """ # Retrieve n_x and n_y from vocab_size n_x, n_y = vocab_size, vocab_size # Initialize parameters parameters = initialize_parameters(n_a, n_x, n_y) # Initialize loss (this is required because we want to smooth our loss, don't worry about it) loss = get_initial_loss(vocab_size, dino_names) # Build list of all dinosaur names (training examples). with open("dinos.txt") as f: examples = f.readlines() examples = [x.lower().strip() for x in examples] # Shuffle list of all dinosaur names np.random.seed(0) np.random.shuffle(examples) # Initialize the hidden state of your LSTM a_prev = np.zeros((n_a, 1)) # Optimization loop for j in range(num_iterations): ### START CODE HERE ### # Use the hint above to define one training example (X,Y) (≈ 2 lines) index = j % len(examples) X = [None] + [char_to_ix[ch] for ch in examples[index]] Y = X[1:] + [char_to_ix["\n"]] # Perform one optimization step: Forward-prop -> Backward-prop -> Clip -> Update parameters # Choose a learning rate of 0.01 curr_loss, gradients, a_prev = optimize(X, Y, a_prev, parameters, learning_rate = 0.01) ### END CODE HERE ### # Use a latency trick to keep the loss smooth. It happens here to accelerate the training. loss = smooth(loss, curr_loss) # Every 2000 Iteration, generate "n" characters thanks to sample() to check if the model is learning properly if j % 2000 == 0: print('Iteration: %d, Loss: %f' % (j, loss) + '\n') # The number of dinosaur names to print seed = 0 for name in range(dino_names): # Sample indices and print them sampled_indices = sample(parameters, char_to_ix, seed) print_sample(sampled_indices, ix_to_char) seed += 1 # To get the same result for grading purposed, increment the seed by one. print('\n') return parameters ###Output _____no_output_____ ###Markdown Run the following cell, you should observe your model outputting random-looking characters at the first iteration. After a few thousand iterations, your model should learn to generate reasonable-looking names. ###Code parameters = model(data, ix_to_char, char_to_ix) ###Output Iteration: 0, Loss: 23.087336 Nkzxwtdmfqoeyhsqwasjkjvu Kneb Kzxwtdmfqoeyhsqwasjkjvu Neb Zxwtdmfqoeyhsqwasjkjvu Eb Xwtdmfqoeyhsqwasjkjvu Iteration: 2000, Loss: 27.884160 Liusskeomnolxeros Hmdaairus Hytroligoraurus Lecalosapaus Xusicikoraurus Abalpsamantisaurus Tpraneronxeros Iteration: 4000, Loss: 25.901815 Mivrosaurus Inee Ivtroplisaurus Mbaaisaurus Wusichisaurus Cabaselachus Toraperlethosdarenitochusthiamamumamaon Iteration: 6000, Loss: 24.608779 Onwusceomosaurus Lieeaerosaurus Lxussaurus Oma Xusteonosaurus Eeahosaurus Toreonosaurus Iteration: 8000, Loss: 24.070350 Onxusichepriuon Kilabersaurus Lutrodon Omaaerosaurus Xutrcheps Edaksoje Trodiktonus Iteration: 10000, Loss: 23.844446 Onyusaurus Klecalosaurus Lustodon Ola Xusodonia Eeaeosaurus Troceosaurus Iteration: 12000, Loss: 23.291971 Onyxosaurus Kica Lustrepiosaurus Olaagrraiansaurus Yuspangosaurus Eealosaurus Trognesaurus Iteration: 14000, Loss: 23.382339 Meutromodromurus Inda Iutroinatorsaurus Maca Yusteratoptititan Ca Troclosaurus Iteration: 16000, Loss: 23.288447 Meuspsangosaurus Ingaa Iusosaurus Macalosaurus Yushanis Daalosaurus Trpandon Iteration: 18000, Loss: 22.823526 Phytrolonhonyg Mela Mustrerasaurus Peg Ytronorosaurus Ehalosaurus Trolomeehus Iteration: 20000, Loss: 23.041871 Nousmofonosaurus Loma Lytrognatiasaurus Ngaa Ytroenetiaudostarmilus Eiafosaurus Troenchulunosaurus Iteration: 22000, Loss: 22.728849 Piutyrangosaurus Midaa Myroranisaurus Pedadosaurus Ytrodon Eiadosaurus Trodoniomusitocorces Iteration: 24000, Loss: 22.683403 Meutromeisaurus Indeceratlapsaurus Jurosaurus Ndaa Yusicheropterus Eiaeropectus Trodonasaurus Iteration: 26000, Loss: 22.554523 Phyusaurus Liceceron Lyusichenodylus Pegahus Yustenhtonthosaurus Elagosaurus Trodontonsaurus Iteration: 28000, Loss: 22.484472 Onyutimaerihus Koia Lytusaurus Ola Ytroheltorus Eiadosaurus Trofiashates Iteration: 30000, Loss: 22.774404 Phytys Lica Lysus Pacalosaurus Ytrochisaurus Eiacosaurus Trochesaurus Iteration: 32000, Loss: 22.209473 Mawusaurus Jica Lustoia Macaisaurus Yusolenqtesaurus Eeaeosaurus Trnanatrax Iteration: 34000, Loss: 22.396744 Mavptokekus Ilabaisaurus Itosaurus Macaesaurus Yrosaurus Eiaeosaurus Trodon ###Markdown ConclusionYou can see that your algorithm has started to generate plausible dinosaur names towards the end of the training. At first, it was generating random characters, but towards the end you could see dinosaur names with cool endings. Feel free to run the algorithm even longer and play with hyperparameters to see if you can get even better results. Our implemetation generated some really cool names like `maconucon`, `marloralus` and `macingsersaurus`. Your model hopefully also learned that dinosaur names tend to end in `saurus`, `don`, `aura`, `tor`, etc.If your model generates some non-cool names, don't blame the model entirely--not all actual dinosaur names sound cool. (For example, `dromaeosauroides` is an actual dinosaur name and is in the training set.) But this model should give you a set of candidates from which you can pick the coolest! This assignment had used a relatively small dataset, so that you could train an RNN quickly on a CPU. Training a model of the english language requires a much bigger dataset, and usually needs much more computation, and could run for many hours on GPUs. We ran our dinosaur name for quite some time, and so far our favoriate name is the great, undefeatable, and fierce: Mangosaurus! 4 - Writing like ShakespeareThe rest of this notebook is optional and is not graded, but we hope you'll do it anyway since it's quite fun and informative. A similar (but more complicated) task is to generate Shakespeare poems. Instead of learning from a dataset of Dinosaur names you can use a collection of Shakespearian poems. Using LSTM cells, you can learn longer term dependencies that span many characters in the text--e.g., where a character appearing somewhere a sequence can influence what should be a different character much much later in ths sequence. These long term dependencies were less important with dinosaur names, since the names were quite short. Let's become poets! We have implemented a Shakespeare poem generator with Keras. Run the following cell to load the required packages and models. This may take a few minutes. ###Code from __future__ import print_function from keras.callbacks import LambdaCallback from keras.models import Model, load_model, Sequential from keras.layers import Dense, Activation, Dropout, Input, Masking from keras.layers import LSTM from keras.utils.data_utils import get_file from keras.preprocessing.sequence import pad_sequences from shakespeare_utils import * import sys import io ###Output Using TensorFlow backend. ###Markdown To save you some time, we have already trained a model for ~1000 epochs on a collection of Shakespearian poems called [*"The Sonnets"*](shakespeare.txt). Let's train the model for one more epoch. When it finishes training for an epoch---this will also take a few minutes---you can run `generate_output`, which will prompt asking you for an input (`<`40 characters). The poem will start with your sentence, and our RNN-Shakespeare will complete the rest of the poem for you! For example, try "Forsooth this maketh no sense " (don't enter the quotation marks). Depending on whether you include the space at the end, your results might also differ--try it both ways, and try other inputs as well. ###Code print_callback = LambdaCallback(on_epoch_end=on_epoch_end) model.fit(x, y, batch_size=128, epochs=1, callbacks=[print_callback]) # Run this cell to try with different inputs without having to re-train the model generate_output() ###Output Write the beginning of your poem, the Shakespeare machine will complete it. Your input is: she was lover Here is your poem: she was lover, his hast outhing thregen so reverle deange, and tonmen leps perentore his babe, and thangs shise in withen my by beling, in grein my soncues of twyrite's falber, spethenss thereor new i rend i thy shall. in a ever as worst your my foerered, ar habver had in newen hery dounged, switt is beited wintt forten be thas hele, ner thine thad direfoled to stans me the bear. ser to bignore lasty be onde
Kata09/kata09.ipynb
###Markdown Ejercicio 1 ###Code # Función para leer 3 tanques de combustible y muestre el promedio def Promedio(a, b , c): return (a + b + c) /3 def Reporte(tanque1, tanque2, tanque3): # promedio = Promedio(tanque1, tanque2 , tanque3) return print( f"""Fuel Report: Total Average: {Promedio(tanque1, tanque2 , tanque3)}% Main tank: {tanque1}% External tank: {tanque2}% Hydrogen tank: {tanque3}% """ ) Reporte(88, 76, 70) ###Output Fuel Report: Total Average: 78.0% Main tank: 88% External tank: 76% Hydrogen tank: 70% ###Markdown Ejercicio 2: Trabajo con argumentos de palabra clave ###Code # Función con un informe preciso de la misión. Considera hora de prelanzamiento, tiempo de vuelo, destino, tanque externo y tanque interno def missionReport(prelanzamiento, timeFlight, destination, externalTank, mainTank): return f""" Mission to: {destination} Total travel time: {prelanzamiento + timeFlight} minutes Total fuel left: {externalTank + mainTank} gallons """ def missionReport1(destination, *minutes, **fuel_reservoirs): return f""" Mission to: {destination} Total travel time: {sum(minutes)} minutes Total fuel left: {sum(fuel_reservoirs.values())} """ def missionReport2(destination, *minutes, **fuel_reservoirs): main_report = f""" Mission to {destination} Total travel time: {sum(minutes)} minutes Total fuel left: {sum(fuel_reservoirs.values())} """ for tank_name, gallons in fuel_reservoirs.items(): main_report += f"{tank_name} tank --> {gallons} gallons left\n" return main_report print(missionReport2("Moon", 8, 11, 55, main=300000, external=200000,interno=1)) # print(missionReport1("Moon", 10, 15, 51, 24, main=300000, external=200000, interno=1)) ###Output Mission to Moon Total travel time: 74 minutes Total fuel left: dict_keys(['main', 'external', 'interno'])
code/playgrounds/fancy_numpy_stuff.ipynb
###Markdown How to take the k biggest values along a given axis for a given matrix: ###Code x = np.random.rand(5, 5) print(x) a = np.argsort(x, axis=1) # argsort gives ascending order so we have to reverse the order a = a[:, -1::-1] print(a) # a contains only the indices along the second axis (the columns) but for integer indexing we also need the row indices: # they will be broadcasted so we need it to be 2D array rows = np.arange(5)[:, np.newaxis] print(rows) print(x[rows, a[:, 0:3]]) ###Output [[0.60080737 0.67869159 0.2950931 0.22690127 0.43422898] [0.82156904 0.72417623 0.60568798 0.46421807 0.78133806] [0.44970497 0.76147525 0.64039773 0.02456953 0.30827886] [0.56624744 0.77421173 0.7109107 0.19469638 0.00313829] [0.75471545 0.90058493 0.74241208 0.88063427 0.55420083]] [[1 0 4 2 3] [0 4 1 2 3] [1 2 0 4 3] [1 2 0 3 4] [1 3 0 2 4]] [[0] [1] [2] [3] [4]] [[0.67869159 0.60080737 0.43422898] [0.82156904 0.78133806 0.72417623] [0.76147525 0.64039773 0.44970497] [0.77421173 0.7109107 0.56624744] [0.90058493 0.88063427 0.75471545]]
notebooks/MakingPrettierGraphs.ipynb
###Markdown Making Prettier Graphs---[Author] ERGM--- If you wish to make prettier graphs please read onwards: ###Code #1st off lets load the various libaries, etc that we need: #this command to tell Jupyter to plot figures inline with the text %matplotlib inline # import pyfolding, the pyfolding models and ising models import pyfolding from pyfolding import * # import the package for plotting, call it plt import matplotlib.pyplot as plt # import numpy as well import numpy as np ###Output _____no_output_____ ###Markdown --- Now, we need to load some data to analyse.In this notebook I will be using data from the paper below:```Mapping the Topography of a Protein Energy LandscapeHutton, R. D., Wilkinson, J., Faccin, M., Sivertsson, E. M., Pelizzola, A., Lowe, A. R., Bruscolini, P. & Itzhaki, L. S.J Am Chem Soc (2015) 127, 46: 14610-25```[http://pubs.acs.org/doi/10.1021/jacs.5b07370] Considerations1. Kinetics data should be entered as rate constants ( *k* ) and NOT as the `log` of the rate constant.2. There can be no "empty" cells between data points in the .csv file for kinetics data. ###Code # start by loading a data set # arguments are "path", "filename" # loading the data - The kinetics of each protein is in one .csv as per the example .csv above pth = "/Users/ergm/Dropbox/AlanLoweCollaboration/Datasets/GankyrinFolding" GankyrinChevron = pyfolding.read_kinetic_data(pth,"GankyrinWTChevron.csv") # let's give this dataset a good name GankyrinChevron.ID = 'Gankyrin WT' ###Output _____no_output_____ ###Markdown --- Lets plot the data. ###Code # now plot the equilm data GankyrinChevron.plot() # ...or, custom plotting although this is more advanced! k1_x, k1_y = GankyrinChevron.chevron('k1') # defines the slower chevron rates k2_x, k2_y = GankyrinChevron.chevron('k2') # defines the faster chevron rates plt.figure(figsize=(8,5)) # makes the figure 8cm by 5cm plt.plot(k1_x, k1_y, 'ro', markersize=8) # red filled circles, sized '8' plt.plot(k2_x, k2_y, 'ko', markersize=8) # black filled circles, sized '8' plt.rc('xtick', labelsize=14) # fontsize of the x tick labels plt.rc('ytick', labelsize=14) # fontsize of the y tick labels plt.ylim([-4, 5]) # y axis from 0 to 8 plt.xlim([0, 8]) # x axis from 0 to 5 plt.grid(False) # no grid on the graph plt.xlabel('[GdmHCl] (M)', fontsize=14) # x axis title with fontsize plt.ylabel(r'$\ln k_{obs}$ $(s^{-1})$', fontsize=14) # y axis title with fontsize plt.title('Gankyrin folding kinetics', fontsize=14) # Plot title plt.show() ###Output _____no_output_____
4_ImplementedModels_2_keras_DRAFT.ipynb
###Markdown 4. Definition and Fitting of the ModelTime Series Forecasting (LSTM) We divide the data between train and test data. In total we have 3 years. We'll take for the training the first two years and the thir one leave it to the testing of the training. Thet is the same as taking the first 2/3 of the data to train and the remaining 1/3 to test. 4.1 Test and Training Sets ###Code values = full.values train_hours = int(2*full.shape[0]/3) train = values[:train_hours, :] test = values[train_hours:, :] #Separate them into Variables and Targets n_obs = (n_hours) * n_features train_X, train_y = train[:, :n_obs], train[:, -24*n_features:] test_X, test_y = test[:, :n_obs], test[:, -24*n_features:] # reshape input to be 3D [samples, timesteps, features] train_X = train_X.reshape((train_X.shape[0], (n_hours), n_features)) test_X = test_X.reshape((test_X.shape[0], (n_hours), n_features)) print(train_X.shape, train_y.shape, test_X.shape, test_y.shape) ###Output (17504, 24, 10) (17504, 240) (8753, 24, 10) (8753, 240) ###Markdown 4.2 Defining the Models 4.2.1 Model 1 ###Code # define model model_1 = Sequential() model_1.add(Bidirectional(LSTM(200, activation='relu', return_sequences = True), input_shape=(train_X.shape[1], train_X.shape[2]))) model_1.add(LSTM(200, activation='relu', input_shape=(train_X.shape[1], train_X.shape[2]))) model_1.add(Dense(120)) model_1.add(Dense(240)) model_1.compile(optimizer='adam', loss='mse') # fit model history = model_1.fit(train_X, train_y, epochs=100, batch_size=24, validation_data=(test_X, test_y), verbose=1, shuffle=False) # plot history pyplot.plot(history.history['loss'], label='train') pyplot.plot(history.history['val_loss'], label='test') pyplot.legend() pyplot.show() ###Output _____no_output_____ ###Markdown We create the test_input tensor to see how the network does when predicting. ###Code # make a prediction ypred = model_1.predict(test_X) #print('ypred.shape=',ypred.shape) test_X = test_X.reshape((test_X.shape[0], (n_hours)*n_features)) #print('test_X.shape=',test_X.shape) # invert scaling for forecast inv_ypred = np.concatenate((test_X[:, :n_hours*n_features], ypred), axis=1) full_predicted = scaler.inverse_transform(inv_ypred ) y_predicted = full_predicted[:,-n_hours*n_features:] #print('inv_ypred.shape=',inv_ypred.shape) # invert scaling for actual test_y = test_y.reshape((len(test_y), n_hours*n_features)) inv_y = np.concatenate((test_X[:, -n_hours*n_features:], test_y), axis=1) full_actual = scaler.inverse_transform(inv_y) y_actual = full_actual[:,-n_hours*n_features:] #print('inv_y.shape=',inv_y.shape) # calculate RMSE rmse = np.sqrt(mean_squared_error(y_predicted, y_actual)) print('Test RMSE: %.3f' % rmse) predicted = pd.DataFrame(data=full_predicted, columns=full.columns) actual = pd.DataFrame(data=full_actual, columns=full.columns) def extract_variable_df(actual_name, in_dataframe): out_dataframe = pd.DataFrame() for i in range(24): if i == 0: out_dataframe['{}_t{}'.format(actual_name, i)] = in_dataframe['{}(t)'.format(actual_name)] else: out_dataframe['{}_t{}'.format(actual_name, i)] = in_dataframe['{}(t+{})'.format(actual_name, i)] return out_dataframe pred_electricity = extract_variable_df('electricity', predicted) actual_electricity = extract_variable_df('electricity', actual) Predicted = go.Scatter(x=np.arange(pred_electricity.shape[1]), y=pred_electricity.values[48], opacity = 1, name = 'Forecasted Value', line=dict(color='royalblue'), yaxis='y') Actual = go.Scatter(x=np.arange(actual_electricity.shape[1]), y=actual_electricity.values[48], opacity = 0.7, name = 'Actual Value', line=dict(color='lightblue'), yaxis='y') layout = go.Layout(title='Electricity Forecasting', xaxis=dict(title='Hour'), yaxis=dict(title='kBTU', overlaying='y'), yaxis2=dict(title='kBTU', side='right')) fig = go.Figure(data=[Predicted, Actual], layout=layout) fig.show() ###Output _____no_output_____
ipynb/consensus_and_profile.ipynb
###Markdown Consensus and Profile ProblemA matrix is a rectangular table of values divided into rows and columns. An **m × n** matrix has **m** rows and **n** columns. Given a matrix **A**, we write A_i,j to indicate the value found at the intersection of row **i** and column **j**.Say that we have a collection of DNA strings, all having the same length **n**. Their profile matrix is a **4 × n** matrix **P** in which **P_1,j** represents the number of times that 'A' occurs in the **j-th** position of one of the strings, **P_2,j** represents the number of times that 'C' occurs in the **j-th** position, and so on.A consensus string **c** is a string of length **n** formed from our collection by taking the most common symbol at each position; the **j-th** symbol of **c** therefore corresponds to the symbol having the maximum value in the **j-th** column of the profile matrix. Of course, there may be more than one most common symbol, leading to multiple possible consensus strings.----------------------| DNA strings |---------------------| A T C C A G C T || G G G C A A C T || A T G G A T C T || A A G C A A C C || T T G G A A C T || A T G C C A T T || A T G G C A C T | ----| Profile |----------------| **A** 5 1 0 0 5 5 0 0 || **C** 0 0 1 4 2 0 6 1 || **G** 1 1 6 3 0 1 0 0 || **T** 1 5 0 0 0 1 1 6 |**Consensus** A T G C A A C T> **Given:** A collection of at most 10 DNA strings of equal length (at most 1 kbp) in FASTA format.> **Return:** A consensus string and profile matrix for the collection. (If several possible consensus strings exist, then you may return any one of them.) ###Code def read_fasta(fp): name, seq = None, [] for line in fp: line = line.rstrip() if line.startswith(">"): if name: yield (name, ''.join(seq)) name, seq = line, [] else: seq.append(line) if name: yield (name, ''.join(seq)) data_list = [] file = open('main.out','w') with open('rosalind_cons.txt') as fp: #replace filename with yours for name, seq in read_fasta(fp): data_list.append(seq) length = len(data_list) # length of string L = len(seq) P = [[0 for x in xrange(L)] for y in xrange(4)] Q = ['A','C','G','T'] for x in range(L): for y in range(4): for z in range(length): P[y][x] = P[y][x] + data_list[z][x].count(Q[y]) domi = "" for x in range(L): MAX = 0 for y in range(4): if P[y][x]>=P[MAX][x]: MAX = y if MAX == 0: domi = domi+'A' elif MAX ==1: domi = domi+'C' elif MAX ==2: domi = domi+'G' elif MAX ==3: domi = domi+'T' file.write('%s\n%s\n%s\n%s\n%s' %( domi,'A: '+str(P[0]).strip('[]').replace(',',''),'C: ' +str(P[1]).strip('[]').replace(',',''),'G: ' +str(P[2]).strip('[]').replace(',',''),'T: ' +str(P[3]).strip('[]').replace(',',''))) ###Output _____no_output_____
02. Color processing/[homework]color_processing.ipynb
###Markdown Домашняя работа 2[Форма](https://forms.gle/GPHZ9AGPpU922vHC7) для отправки решения. ДЕДЛАЙНЫ:Задача №1 - 10 янв 23:59Задача №2 - 10 янв 23:59Укажите в названии файла: 1. имя и фамилия2. номер домашки3. номер задания(NAME_LES_TASK.ipynb) Задача №1 - Лес или пустыня?Часто при анализе изображений местности необходимо понять ее характер. В частности, если определить, что на изображении преобладет вода, то имеет смысл искать корабли на таком изображении. Если на картинке густой лес, то, возможно, это не лучшая зона для посадки дрона или беспилотника.Ваша задача - написать программу, которая будет отличать лес от пустыни. В приложении можно найти реальные спутниковые снимки лесов и пустынь.Примеры изображений: ###Code # Ваш код ###Output _____no_output_____ ###Markdown Задача №2 - Кусочки пазла.Даны кусочки изображения, ваша задача склеить пазл в исходную картинку. Условия:* Дано исходное изображение для проверки, использовать собранное изображение в самом алгоритме нельзя;* В качестве первого изображения, начиная с которого нужно собрать пазл, всегда принимается верхняя левая часть изображения;* В процессе проверки решения пазлы могут быть перемешаны, т.е. порядок пазлов в проверке может отличаться от исходного Примеры изображений: ###Code # Ваш код ###Output _____no_output_____
nircam_jdox/nircam_grism_time_series/figure2_grism_throughput_order1.ipynb
###Markdown Figure 2: Grism Throughput Response for LW Filters ($1^{st}$ Order) *** Table of Contents1. [Information](Information)2. [Imports](Imports)3. [Data](Data)4. [Generate the First Order Throughput Response Plot](Generate-the-First-Order-Throughput-Response-Plot)5. [Issues](Issues)6. [About this Notebook](About-this-Notebook)*** Information JDox links: * [NIRCam Grism Time Series](https://jwst-docs.stsci.edu/display/JTI/NIRCam+Grism+Time+SeriesNIRCamGrismTimeSeries-Filters) * Figure 2: Throughput response for NIRCam grism and long wavelength filters ($1^{st}$ order) Imports ###Code import os import pylab import numpy as np import pysynphot as S from astropy.io import ascii from astropy.table import Table import requests import matplotlib.pyplot as plt %matplotlib inline ###Output _____no_output_____ ###Markdown Data Data Location: The data is stored in a NIRCam JDox Box folder here:[ST-INS-NIRCAM -> JDox -> nircam_grism_time_series](https://stsci.box.com/s/tf6049a75u6f3uc26q3xu6w8tv456pk7) ###Code files = [('https://stsci.box.com/shared/static/p3sfybd8efc83qv89ds1vnflnz2noq3b.txt', 'F070W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/ops33fuuaiz79qcv26srmussv14ousuz.txt', 'F090W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/bcdj04zp58liw9egpy7y889zcctcdx86.txt', 'F115W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/o0vw1ih8yfiq97afmcbkrjgzep52umdf.txt', 'F140M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/sfxywmlhcj1rg9cn7jsjipvnexqba2pc.txt', 'F150W2_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/iznsxikuh4sshfmvmwhdfzbos0t5tp76.txt', 'F150W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/ynn2cslbli9pu6lpam7q4ii3uhy8csc5.txt', 'F162M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/hqwuuk0cwzh244ip07ynlov1em1qxzd2.txt', 'F164N_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/bi6oe3xm3xzqjeiv4fd9jiw45abxypss.txt', 'F182M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/3kkfo2vipr30llc3segu3jybgnp1b5wy.txt', 'F187N_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/knanodd82bisgl9jm8kkolzx7clz0n6v.txt', 'F200W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/fn48mlbqwfb1iks2oiuhmbog0zrmt5cn.txt', 'F210M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/2wdne7tkfmdov5avedef3zypwzzwhavr.txt', 'F212N_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/5eswzma6gtld0kgksc7wdeajjwhdycso.txt', 'F250M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/88kjudlxg00fu1g1ep5vpzh2d2rey7i1.txt', 'F277W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/djjq4dmrmwa90yfgzjra6nzugwyecoqm.txt', 'F300M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/0orsgodf2k33h65yxyd651p3q37zgrhe.txt', 'F322W2_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/z5pz3m31xzqolo56n4x1eac9nvnpaabz.txt', 'F323N_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/r83zb002r4ga42rv1gxyzwymbj8hz1hl.txt', 'F335M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/l68ztc38lok2xdsxvrtjlp57sbsrh1n7.txt', 'F356W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/ib7v9la4jfzjvmxeure35upr7elw1epa.txt', 'F360M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/xwxp2rc3bz3rqndd5ximhlcwp9kypkqr.txt', 'F405N_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/xwrox8e8puh7uwazl2q43fspbifd7gpu.txt', 'F410M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/rsuq0nalldng8tplgi8x24tztkdcbzfc.txt', 'F430M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/ifka343brbjh2tvkugsdhfeujp6b1iqn.txt', 'F444W_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/rvkqjp0s0b709phimtmdvl641fpexxer.txt', 'F460M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/kestno7niryilo4c0t91a9z7vmth4751.txt', 'F466N_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/xlh9t4k2breqipeq5io4y5x2jp2m7myn.txt', 'F470N_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/hx47qygujmo0c8kl94kcrxvwr01msrxc.txt', 'F480M_NRC_and_OTE_ModAB_mean.txt'), ('https://stsci.box.com/shared/static/q002uyvir8h5q9i0wuwdgugtxp274fe3.fits', 'jwst_nircam_f070w_moda_trans.fits'), ('https://stsci.box.com/shared/static/v621d7261r7u3oklvwq7h8jcpvuc11va.fits', 'jwst_nircam_f070w_modb_trans.fits'), ('https://stsci.box.com/shared/static/0yc9u7qd7xz1nuuaeiiplyizs56xsdcg.fits', 'jwst_nircam_f070w_trans.fits'), ('https://stsci.box.com/shared/static/emt5mhp2he7akjmd1q5gc6tlyb8hlvd0.fits', 'jwst_nircam_f090w_moda_trans.fits'), ('https://stsci.box.com/shared/static/087tgi8n7d954zslcq3cwva6gowqhr9u.fits', 'jwst_nircam_f090w_modb_trans.fits'), ('https://stsci.box.com/shared/static/vqes8f08a626t9g27s7eraztvta8d2d1.fits', 'jwst_nircam_f090w_trans.fits'), ('https://stsci.box.com/shared/static/r90ou18ouufa2hyliyzal00llrcvgsgt.fits', 'jwst_nircam_f115w_moda_trans.fits'), ('https://stsci.box.com/shared/static/q4s6k5x03xm9r7il4vwks1bcaq7ll2ep.fits', 'jwst_nircam_f115w_modb_trans.fits'), ('https://stsci.box.com/shared/static/hrxhow0nt9k17bkf0znotjgu3xuls4zw.fits', 'jwst_nircam_f115w_trans.fits'), ('https://stsci.box.com/shared/static/tfzruo3qef0c2w3djxx2f9mx9q3k3e26.fits', 'jwst_nircam_f140m_moda_trans.fits'), ('https://stsci.box.com/shared/static/001iq06zqvj8ue9o83j0de7hevfaquxk.fits', 'jwst_nircam_f140m_modb_trans.fits'), ('https://stsci.box.com/shared/static/3vl8ifi4ottw6j9mskozl2ja4eqpee4q.fits', 'jwst_nircam_f140m_trans.fits'), ('https://stsci.box.com/shared/static/ipxyd17ap5uoknh8yhq1d0phl5v3qev3.fits', 'jwst_nircam_f150w2_moda_trans.fits'), ('https://stsci.box.com/shared/static/14yxoyt9m5nnln1f214uonbm40ouosvo.fits', 'jwst_nircam_f150w2_modb_trans.fits'), ('https://stsci.box.com/shared/static/eyn84gua40i76lujc6ytgqmksdhusrio.fits', 'jwst_nircam_f150w2_trans.fits'), ('https://stsci.box.com/shared/static/cqm9zx2qp71vbropsv9gl78ku0soig76.fits', 'jwst_nircam_f150w_moda_trans.fits'), ('https://stsci.box.com/shared/static/f5ytcqlr0d3qb2f9by5e9muk57y7fpzn.fits', 'jwst_nircam_f150w_modb_trans.fits'), ('https://stsci.box.com/shared/static/z0alz51pjnawgwy49cpew6fteand92sr.fits', 'jwst_nircam_f150w_trans.fits'), ('https://stsci.box.com/shared/static/1yjs6dskrir0k2k5lli0n4e4q8ui0nk5.fits', 'jwst_nircam_f162m_moda_trans.fits'), ('https://stsci.box.com/shared/static/f2s4mt01mmsj7ukb29fl36oumnq4lwsl.fits', 'jwst_nircam_f162m_modb_trans.fits'), ('https://stsci.box.com/shared/static/b944mc6y29p5gsz7flyrrectzz80lq7m.fits', 'jwst_nircam_f162m_trans.fits'), ('https://stsci.box.com/shared/static/ivimch76f0gkgte3ehtlk0sbp31ky995.fits', 'jwst_nircam_f164n_moda_trans.fits'), ('https://stsci.box.com/shared/static/2mlngldc0oel1erccp435egj6hsdh8bk.fits', 'jwst_nircam_f164n_modb_trans.fits'), ('https://stsci.box.com/shared/static/h7vngf9b3hk2bnnquubptgahr4ddy35t.fits', 'jwst_nircam_f164n_trans.fits'), ('https://stsci.box.com/shared/static/lrtpz42dehiyxyn1i57rqtss3zmo5m82.fits', 'jwst_nircam_f182m_moda_trans.fits'), ('https://stsci.box.com/shared/static/7wnlka8jmrp2cbf213zr6sj9nxzz1b6h.fits', 'jwst_nircam_f182m_modb_trans.fits'), ('https://stsci.box.com/shared/static/gkics13m42hixktgi01no3k3e4mdlbfa.fits', 'jwst_nircam_f182m_trans.fits'), ('https://stsci.box.com/shared/static/zy62f09jt4qhdpmpi06oupt1j0cwvnoi.fits', 'jwst_nircam_f187n_moda_trans.fits'), ('https://stsci.box.com/shared/static/oz3gvx2ifxmqcoq58wh27y6xc8xb1vup.fits', 'jwst_nircam_f187n_modb_trans.fits'), ('https://stsci.box.com/shared/static/zioq21vr5c0knayu7vbydupo42y14iy1.fits', 'jwst_nircam_f187n_trans.fits'), ('https://stsci.box.com/shared/static/nqmjloz1czufvn2kdcq4ratuzoyobeb2.fits', 'jwst_nircam_f200w_moda_trans.fits'), ('https://stsci.box.com/shared/static/0f80l7n1735oyb0lyecu9bfbtsbxep8y.fits', 'jwst_nircam_f200w_modb_trans.fits'), ('https://stsci.box.com/shared/static/coagdaiiqwsvrosccrrdyzhwbwifffit.fits', 'jwst_nircam_f200w_trans.fits'), ('https://stsci.box.com/shared/static/vqqicdwx55tgruvxvxtu18utmliyk3zx.fits', 'jwst_nircam_f210m_moda_trans.fits'), ('https://stsci.box.com/shared/static/id6v2oz6ui6i3aho65jb1x4dtzk08v80.fits', 'jwst_nircam_f210m_modb_trans.fits'), ('https://stsci.box.com/shared/static/onv7qidjadzk8hl8uexux8o7s6ubuxd2.fits', 'jwst_nircam_f210m_trans.fits'), ('https://stsci.box.com/shared/static/oabpu1eyv17eurs3jle3cqcv4td7zlw0.fits', 'jwst_nircam_f212n_moda_trans.fits'), ('https://stsci.box.com/shared/static/necxttcispe8lrlvfjenp6y1i2wqzf4q.fits', 'jwst_nircam_f212n_modb_trans.fits'), ('https://stsci.box.com/shared/static/so5wgxnot995yi20m0myqg67n1n0szq0.fits', 'jwst_nircam_f212n_trans.fits'), ('https://stsci.box.com/shared/static/bhzst8us5qegi2zmfgtf2k13eijbo0yh.fits', 'jwst_nircam_f250m_moda_trans.fits'), ('https://stsci.box.com/shared/static/n525hr454e3muwa8hjg2s3pc649b90io.fits', 'jwst_nircam_f250m_modb_trans.fits'), ('https://stsci.box.com/shared/static/t9wea2b7ynlqum42cazs3uog1ncw9nql.fits', 'jwst_nircam_f250m_trans.fits'), ('https://stsci.box.com/shared/static/zpxqwg0fr3d3baokajh50t8orou8ai6w.fits', 'jwst_nircam_f277w_moda_trans.fits'), ('https://stsci.box.com/shared/static/hlagbg669x27xx26i1voef2dysmb8gqm.fits', 'jwst_nircam_f277w_modb_trans.fits'), ('https://stsci.box.com/shared/static/nep9ebnmoyogmup48gkifnekour2du3b.fits', 'jwst_nircam_f277w_trans.fits'), ('https://stsci.box.com/shared/static/77m4vzldbjvyesnmak7a8yrivie3abj1.fits', 'jwst_nircam_f300m_moda_trans.fits'), ('https://stsci.box.com/shared/static/ywl67tyf7h67e84kccqfjmj68kjk5946.fits', 'jwst_nircam_f300m_modb_trans.fits'), ('https://stsci.box.com/shared/static/29ysbdq1ijvjayex5dsjx8fqck6pc57m.fits', 'jwst_nircam_f300m_trans.fits'), ('https://stsci.box.com/shared/static/ji9pz1symqweujoxwfg1k94vma0t8w7h.fits', 'jwst_nircam_f322w2_moda_trans.fits'), ('https://stsci.box.com/shared/static/7g2ml1dfcsjkhthzaa2d64kxq2l2ozvo.fits', 'jwst_nircam_f322w2_modb_trans.fits'), ('https://stsci.box.com/shared/static/18344rcr1mgehveuuq5ouh5gdadtizgl.fits', 'jwst_nircam_f322w2_trans.fits'), ('https://stsci.box.com/shared/static/asn3qkwhf0j2f59j7a5c3jr8vmkd1hf8.fits', 'jwst_nircam_f323n_moda_trans.fits'), ('https://stsci.box.com/shared/static/znnt66i6muj1r2ggdy85jkayq79h50cn.fits', 'jwst_nircam_f323n_modb_trans.fits'), ('https://stsci.box.com/shared/static/hj9i2hjgnyukxg0g3hl7g1xll70fcknt.fits', 'jwst_nircam_f323n_trans.fits'), ('https://stsci.box.com/shared/static/bh7fot8pkstl8slffktbzmokoiptnmdg.fits', 'jwst_nircam_f335m_moda_trans.fits'), ('https://stsci.box.com/shared/static/5n9b8f70405d97z3er1688g5mfcc53db.fits', 'jwst_nircam_f335m_modb_trans.fits'), ('https://stsci.box.com/shared/static/yb3o86rbicpud401xw5woi230ipwe88y.fits', 'jwst_nircam_f335m_trans.fits'), ('https://stsci.box.com/shared/static/3a24wuinnrlmz3fwgbhn0b66topjix9k.fits', 'jwst_nircam_f356w_moda_trans.fits'), ('https://stsci.box.com/shared/static/x31rhyxm832gxnyov2bvxbluesxl2oj3.fits', 'jwst_nircam_f356w_modb_trans.fits'), ('https://stsci.box.com/shared/static/qz3ugwcw3dmjt0jcfyrnhnboo7x7yxj1.fits', 'jwst_nircam_f356w_trans.fits'), ('https://stsci.box.com/shared/static/iq75hpd6njl4znq0sg9oll9l1xh15l09.fits', 'jwst_nircam_f360m_moda_trans.fits'), ('https://stsci.box.com/shared/static/mphs45niz6p3tke1o4jw4b0i0io7qt0g.fits', 'jwst_nircam_f360m_modb_trans.fits'), ('https://stsci.box.com/shared/static/cwxdluohobrcpk32qq9osgzc7o651pa4.fits', 'jwst_nircam_f360m_trans.fits'), ('https://stsci.box.com/shared/static/jytl3abr69pjvn3vwcii0573ijkbo7sb.fits', 'jwst_nircam_f405n_moda_trans.fits'), ('https://stsci.box.com/shared/static/77w780bfxtxess80a6p0zsaykj49p6mx.fits', 'jwst_nircam_f405n_modb_trans.fits'), ('https://stsci.box.com/shared/static/wb8cdpdxml8fjqbz118ohmhqydfy95eu.fits', 'jwst_nircam_f405n_trans.fits'), ('https://stsci.box.com/shared/static/5i3hdxhswzi98eunjajscxxxj9i9pv4e.fits', 'jwst_nircam_f410m_moda_trans.fits'), ('https://stsci.box.com/shared/static/wh1gxudiw5bx9du0ch85wl55mkd2304c.fits', 'jwst_nircam_f410m_modb_trans.fits'), ('https://stsci.box.com/shared/static/cwqu9d7fars0o8jxn0fi559sc82h8u0s.fits', 'jwst_nircam_f410m_trans.fits'), ('https://stsci.box.com/shared/static/i1q4on0xoh86uqtwhg1czp4k66ui9af5.fits', 'jwst_nircam_f430m_moda_trans.fits'), ('https://stsci.box.com/shared/static/afm1b6sjgjc18as5ldszatgesmle97z2.fits', 'jwst_nircam_f430m_modb_trans.fits'), ('https://stsci.box.com/shared/static/q2jn74ra7oi4lgklpv6b0y75sjytguqf.fits', 'jwst_nircam_f430m_trans.fits'), ('https://stsci.box.com/shared/static/z7s8qsejqyqaupfk3rwf1bxg5xcknu5o.fits', 'jwst_nircam_f444w_moda_trans.fits'), ('https://stsci.box.com/shared/static/q9aeblatsq9p5lzgq9g2rzryfjg201r7.fits', 'jwst_nircam_f444w_modb_trans.fits'), ('https://stsci.box.com/shared/static/xnl9t1xf3md1wzljb1lu9t8s1jgssxvg.fits', 'jwst_nircam_f444w_trans.fits'), ('https://stsci.box.com/shared/static/sm91chlb3bx5bi681bew3g7q7j953r97.fits', 'jwst_nircam_f460m_moda_trans.fits'), ('https://stsci.box.com/shared/static/lfrcunsgb9j5zkv1ndw76rfzs8i2qmib.fits', 'jwst_nircam_f460m_modb_trans.fits'), ('https://stsci.box.com/shared/static/46ggp89lwcap1e1t6l4e9hubr7wwlm9b.fits', 'jwst_nircam_f460m_trans.fits'), ('https://stsci.box.com/shared/static/dyys9qu87xs4fos558jduxmm4ie498g8.fits', 'jwst_nircam_f466n_moda_trans.fits'), ('https://stsci.box.com/shared/static/0286ejhytmm17edmb6wsdoe4gwaycti7.fits', 'jwst_nircam_f466n_modb_trans.fits'), ('https://stsci.box.com/shared/static/6rtqsgk5hvq7gzwa6i6ezbuc7xc1mgtw.fits', 'jwst_nircam_f466n_trans.fits'), ('https://stsci.box.com/shared/static/4x8x01ihh8qscll6ol4ds5lmgag9b2iy.fits', 'jwst_nircam_f470n_moda_trans.fits'), ('https://stsci.box.com/shared/static/4hk9vtkqporxj98ay7h9jfnx3cky97aa.fits', 'jwst_nircam_f470n_modb_trans.fits'), ('https://stsci.box.com/shared/static/e0v1oim4u8lqdtpetsminmlkae73ccp1.fits', 'jwst_nircam_f470n_trans.fits'), ('https://stsci.box.com/shared/static/ucg4cdwf566xaorpdv3utrykhvkld2gs.fits', 'jwst_nircam_f480m_moda_trans.fits'), ('https://stsci.box.com/shared/static/qefjdc97u8mz18uu2nc513a2yxrqm6jh.fits', 'jwst_nircam_f480m_modb_trans.fits'), ('https://stsci.box.com/shared/static/kdttpdh2krrco6tno2tvroi6om87xfkk.fits', 'jwst_nircam_f480m_trans.fits')] def download_file(url, file_name, output_directory='./', overwrite=False): """Download a file from Box given the direct URL Parameters ---------- url : str URL to the file to be downloaded file_name : str The name of the file being downloaded output_directory : str Directory to download file_name into overwrite : str If False and the file to download already exists, the download will be skipped. If True, the file will be downloaded regardless of whether it already exists in output_directory Returns ------- download_filename : str Name of the downloaded file """ download_filename = os.path.join(output_directory, file_name) if not os.path.isfile(download_filename) or overwrite is True: print("Downloading {}".format(file_name)) with requests.get(url, stream=True) as response: if response.status_code != 200: raise RuntimeError("Wrong URL - {}".format(url)) with open(download_filename, 'wb') as f: for chunk in response.iter_content(chunk_size=2048): if chunk: f.write(chunk) else: print("{} already exists. Skipping download.".format(download_filename)) return download_filename ###Output _____no_output_____ ###Markdown Load the data(The next cell assumes you downloaded the data into your ```Users/$(logname)/``` home directory) ###Code if os.environ.get('LOGNAME') is None: raise ValueError("WARNING: LOGNAME environment variable not set!") box_directory = os.path.join("/Users/", os.environ['LOGNAME'], "box_data") box_directory if not os.path.isdir(box_directory): try: os.mkdir(box_directory) except: raise OSError("Unable to create {}".format(box_directory)) for file_info in files: file_url, filename = file_info outfile = download_file(file_url, filename, output_directory=box_directory) filters = ["F250M","F277W","F300M","F322W2","F335M","F356W","F360M","F410M","F430M","F444W","F460M","F480M"] # NIRCAM grism throughputs given to Nor by Tom Greene (November 17, 2017): # First order modAm1 = np.array([0.240,0.306,0.374,0.437,0.494,0.543,0.585,0.620,0.648,0.670,0.686,0.696,0.702,0.705,0.703,0.702,0.694,0.685,0.674,0.661,0.649,0.636,0.621,0.609,0.593,0.579,0.566]) modBm1 = np.array([0.178,0.226,0.276,0.323,0.365,0.401,0.432,0.458,0.479,0.495,0.507,0.514,0.519,0.521,0.520,0.518,0.513,0.506,0.498,0.489,0.479,0.470,0.459,0.450,0.438,0.428,0.418]) # Second order modAm2 = np.array([0.387,0.283,0.210,0.151,0.109,0.079,0.056,0.037,0.024,0.015,0.011,0.005,0.002,0.000,0.000,0.001,0.001,0.001,0.002,0.003,0.005,0.008,0.010,0.011,0.012,0.013,0.014]) modBm2 = np.array([0.286,0.209,0.155,0.111,0.080,0.058,0.041,0.027,0.018,0.011,0.008,0.004,0.002,0.000,0.000,0.001,0.001,0.001,0.002,0.002,0.004,0.006,0.007,0.008,0.009,0.010,0.010]) # Blaze wavelength blaze_w = np.array([2.40,2.50,2.60,2.70,2.80,2.90,3.00,3.10,3.20,3.30,3.40,3.50,3.60,3.70,3.80,3.90,4.00,4.10,4.20,4.30,4.40,4.50,4.60,4.70,4.80,4.90,5.00]) # Include JWST optics? NRC_plus_OTE = True ###Output _____no_output_____ ###Markdown Generate the First Order Throughput Response Plot ###Code NUM_COLORS = len(filters) cm = pylab.get_cmap('tab10') f, ax1 = plt.subplots(1, figsize=(15, 10)) for i,fil in zip(range(NUM_COLORS),filters): if 'W' in fil: color = cm(1.*i/NUM_COLORS) if NRC_plus_OTE: wav, thpt = np.loadtxt(os.path.join(box_directory, fil+'_NRC_and_OTE_ModAB_mean.txt'), unpack=True, skiprows=1) data = S.ArrayBandpass(wav, thpt, name=fil) else: data = S.FileBandpass(os.path.join(box_directory, 'jwst_nircam_'+fil.lower()+'_moda_trans.fits')) maxval = 0.003 ax1.plot(data.wave[data.throughput > maxval],data.throughput[data.throughput > maxval],lw=3,label=fil) ax1.text(4.7, 0.47, 'LW B grism',color='black',alpha=0.65,fontsize=20) ax1.text(4.7, 0.63, 'LW A grism',color='black',fontsize=20) ax1.plot(blaze_w,modAm1,lw=2,color='black',marker='o',markersize=7) ax1.plot(blaze_w,modBm1,lw=2,color='grey',marker='d',markersize=7) miny,maxy = ax1.get_ylim() minx,maxx = ax1.get_xlim() ax1.legend(bbox_to_anchor=(0.16, 1),fontsize=15) ax1.tick_params(labelsize=18) f.text(0.5, 0.04, 'Wavelength ($\mu m$)', ha='center', fontsize=22) f.text(0.05, 0.5, 'Throughput', va='center', rotation='vertical', fontsize=22) ###Output _____no_output_____ ###Markdown Figure option 2: all filters ###Code cm = pylab.get_cmap('tab10') f, ax1 = plt.subplots(1, figsize=(15, 10)) for i,fil in zip(range(NUM_COLORS),filters): color = cm(1.*i/NUM_COLORS) if NRC_plus_OTE: wav, thpt = np.loadtxt(os.path.join(box_directory, fil+'_NRC_and_OTE_ModAB_mean.txt'), unpack=True, skiprows=1) data = S.ArrayBandpass(wav, thpt, name=fil) else: data = S.FileBandpass(os.path.join(box_directory, 'jwst_nircam_'+fil.lower()+'_moda_trans.fits')) maxval = 0.003 ax1.plot(data.wave[data.throughput > maxval],data.throughput[data.throughput > maxval],lw=3,label=fil,color=color) ax1.text(4.7, 0.47, 'LW B grism',color='black',alpha=0.65,fontsize=20) ax1.text(4.7, 0.63, 'LW A grism',color='black',fontsize=20) ax1.plot(blaze_w,modAm1,lw=2,color='black',marker='o',markersize=7) ax1.plot(blaze_w,modBm1,lw=2,color='grey',marker='d',markersize=7) miny,maxy = ax1.get_ylim() minx,maxx = ax1.get_xlim() ax1.legend(bbox_to_anchor=(1., 1.013),fontsize=15) ax1.tick_params(labelsize=18) f.text(0.5, 0.04, 'Wavelength ($\mu m$)', ha='center', fontsize=22) f.text(0.05, 0.5, 'Throughput', va='center', rotation='vertical', fontsize=22) ###Output _____no_output_____
Practices/Practice17_Pandas-Subsetting-II.ipynb
###Markdown Practice: Subsetting Pandas DataFrames IIFor this practice, let's use the `iris` dataset: ###Code # import the pandas package import pandas as pd # set the path path = 'https://raw.githubusercontent.com/GWC-DCMB/curriculum-notebooks/master/' # this is where the file is located filename = path + 'SampleData/iris.csv' # load the iris dataset into a DataFrame iris = pd.read_csv(filename) ###Output _____no_output_____ ###Markdown Take a look at the dataset: ###Code # take a look at the beginning # subset the first 5 rows from iris # save it to a variable called subset1 # subset a few columns from the subset1 dataframe # save it to a variable called subset 2 ###Output _____no_output_____ ###Markdown Let's try subsetting both rows and columns at the same time! ###Code # create a new subset from iris that's identical to subset2 # but write only one line of code # save it to a variable called subset3 # check your work -- how does subset2 compare to subset3? # subset rows 20 through 30 and columns petal_length & petal width # write only one line of code ###Output _____no_output_____ ###Markdown Now let's subset using `query`: ###Code # subset rows where the species is not setosa # subset rows where sepal_width is greater than 4 # subset rows where sepal_width is between 2 and 3 # subset rows where sepal_width is less than 3.5 and the species is virginica # subset rows where the pedal width is 0.3 or the species is versicolor ###Output _____no_output_____ ###Markdown **Bonus**: Try to subset with both `query` and square brackets `[]` on the same line: ###Code # pick any query and any columns to subset with ###Output _____no_output_____
notebook/fraud-detection-catboost.ipynb
###Markdown Data Import libraries: ###Code import pandas as pd from sklearn import preprocessing from sklearn.model_selection import train_test_split import sklearn.metrics as metrics import catboost as cb import gc ###Output _____no_output_____ ###Markdown Import data & combine transaction and idendity columns: ###Code train_transaction = pd.read_csv('/home/fatihakyon/dev/inzva/ieee-fraud-detection/data/train_transaction.csv') train_identity = pd.read_csv('/home/fatihakyon/dev/inzva/ieee-fraud-detection/data/train_identity.csv') train = pd.merge(train_transaction, train_identity, on="TransactionID", how="left") train = train.set_index("TransactionID", drop="True") del train_transaction, train_identity gc.collect() test_transaction = pd.read_csv('/home/fatihakyon/dev/inzva/ieee-fraud-detection/data/test_transaction.csv') test_identity = pd.read_csv('/home/fatihakyon/dev/inzva/ieee-fraud-detection/data/test_identity.csv') test = pd.merge(test_transaction, test_identity, on="TransactionID", how="left") test = test.set_index("TransactionID", drop="True") del test_transaction, test_identity gc.collect() train.shape test.shape train.head() ###Output _____no_output_____ ###Markdown Rename test data columns: ###Code mapping = {} for column_name in test.columns: mapping[column_name] = column_name.replace("-", "_") test.rename(columns=mapping, inplace=True) test.columns ###Output _____no_output_____ ###Markdown Reduce memory usage: ###Code import numpy as np def reduce_mem_usage(df): """ From kernel https://www.kaggle.com/gemartin/load-data-reduce-memory-usage Iterate through all the columns of a dataframe and modify the data type to reduce memory usage. """ start_mem = df.memory_usage().sum() / 1024 ** 2 print("Memory usage of dataframe is {:.2f} MB".format(start_mem)) for col in df.columns: col_type = df[col].dtype if col_type != object: c_min = df[col].min() c_max = df[col].max() if str(col_type)[:3] == "int": if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max: df[col] = df[col].astype(np.int8) elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max: df[col] = df[col].astype(np.int16) elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max: df[col] = df[col].astype(np.int32) elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max: df[col] = df[col].astype(np.int64) else: if ( c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max ): df[col] = df[col].astype(np.float16) elif ( c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max ): df[col] = df[col].astype(np.float32) else: df[col] = df[col].astype(np.float64) else: pass # df[col] = df[col].astype("category") end_mem = df.memory_usage().sum() / 1024 ** 2 print("Memory usage after optimization is: {:.2f} MB".format(end_mem)) print("Decreased by {:.1f}%".format(100 * (start_mem - end_mem) / start_mem)) return df train = reduce_mem_usage(train) test = reduce_mem_usage(test) ###Output Memory usage of dataframe is 1955.37 MB Memory usage after optimization is: 648.22 MB Decreased by 66.8% Memory usage of dataframe is 1673.87 MB Memory usage after optimization is: 563.43 MB Decreased by 66.3% ###Markdown Split train into train/val: ###Code VAL_SPLIT = 0.2 # Split train into train/val y = train["isFraud"].copy() X = train.drop("isFraud", axis=1) X_train, X_val, y_train, y_val = train_test_split( X, y, test_size=VAL_SPLIT, random_state=13 ) X_test = test.copy() del train, test, X, y X_train = X_train.fillna(-999) X_val = X_val.fillna(-999) X_test = X_test.fillna(-999) ###Output _____no_output_____ ###Markdown Categorical features: ###Code categorical_features = [] for f in X_train.columns: if X_train[f].dtype=='object' or X_test[f].dtype=='object': categorical_features.append(f) lbl = preprocessing.LabelEncoder() lbl.fit(list(X_train[f].values) + list(X_test[f].values) + list(X_val[f].values)) X_train[f] = lbl.transform(list(X_train[f].values)) X_val[f] = lbl.transform(list(X_val[f].values)) X_test[f] = lbl.transform(list(X_test[f].values)) ###Output _____no_output_____ ###Markdown CatBoost ###Code clf = cb.CatBoostClassifier(n_estimators=200, learning_rate=0.05, metric_period=500, od_wait=500, task_type='CPU', depth=8) clf.fit(X_train, y_train, cat_features=categorical_features) ###Output 0: learn: 0.6113626 total: 145ms remaining: 28.8s 199: learn: 0.0947855 total: 26.2s remaining: 0us ###Markdown Results: ###Code def calculate_scores(estimator, X_val, y_val): y_val_prediction = estimator.predict(X_val) y_val_proba = estimator.predict_proba(X_val)[:, 1] conf_matrix = metrics.confusion_matrix(y_val, y_val_prediction) accuracy_score = metrics.accuracy_score(y_val, y_val_prediction) roc_auc_score = metrics.roc_auc_score(y_val, y_val_proba) f1_score = metrics.f1_score(y_val, y_val_prediction) classification_report = metrics.classification_report(y_val, y_val_prediction) print("Confusion Matrix: \n%s" % str(conf_matrix)) print("\nAccuracy: %.4f" % accuracy_score) print("\nAUC: %.4f" % roc_auc_score) print("\nF1 Score: %.4f" % f1_score) print("\nClassification Report: \n",classification_report) return { "conf_matrix": conf_matrix, "accuracy_score": accuracy_score, "roc_auc_score": roc_auc_score, "f1_score": f1_score, "classification_report": classification_report } _ = calculate_scores(clf, X_val, y_val) ###Output Confusion Matrix: [[113854 118] [ 2787 1349]] Accuracy: 0.9754 AUC: 0.8755 F1 Score: 0.4815 Classification Report: precision recall f1-score support 0 0.98 1.00 0.99 113972 1 0.92 0.33 0.48 4136 accuracy 0.98 118108 macro avg 0.95 0.66 0.73 118108 weighted avg 0.97 0.98 0.97 118108 ###Markdown Hyperarameter Optimization Randomized Search: ###Code from sklearn.model_selection import RandomizedSearchCV from scipy.stats import uniform as sp_randFloat from scipy.stats import randint as sp_randInt param_grid = { 'silent': [False], 'learning_rate': sp_randFloat(0.01, 0.3), 'n_estimators': [200], 'depth': sp_randInt(6, 16), 'l2_leaf_reg':[3,1,5,10,100], 'loss_function': ['Logloss', 'CrossEntropy'] } def perform_random_search( estimator, X_train, X_val, y_train, y_val, param_grid, scoring=None ): hyperparam_optimizer = RandomizedSearchCV( estimator=estimator, param_distributions=param_grid, scoring=scoring, cv=2, n_iter=20, n_jobs=1, refit=True, random_state=13, ) hyperparam_optimizer.fit(X_train, y_train, eval_set=(X_val, y_val)) return hyperparam_optimizer.best_estimator_ # accuracy score best_estimator = perform_random_search(clf, X_train, X_val, y_train, y_val, param_grid, scoring='accuracy') _ = calculate_scores(best_estimator, X_val, y_val) # roc auc score best_estimator = perform_random_search(clf, X_train, X_val, y_train, y_val, param_grid, scoring='roc_auc') _ = calculate_scores(best_estimator, X_val, y_val) # f1 score best_estimator = perform_random_search(clf, X_train, X_val, y_train, y_val, param_grid, scoring='f1') _ = calculate_scores(best_estimator, X_val, y_val) ###Output Warning: Overfitting detector is active, thus evaluation metric is calculated on every iteration. 'metric_period' is ignored for evaluation metric. ###Markdown Bayesian Search: ###Code from skopt import BayesSearchCV from skopt.space import Real, Categorical, Integer param_grid = { 'silent': [False], 'learning_rate': Real(0.01, 0.3), 'n_estimators': [200], 'depth': Integer(6, 16), 'l2_leaf_reg':[3,1,5,10,100], 'loss_function': ['Logloss', 'CrossEntropy'] } def perform_bayes_search( estimator, X_train, X_val, y_train, y_val, param_grid, scoring=None ): hyperparam_optimizer = BayesSearchCV( estimator=estimator, search_spaces=param_grid, scoring=scoring, cv=2, n_iter=15, n_jobs=1, refit=True, return_train_score=False, optimizer_kwargs={"base_estimator": "GP"}, random_state=13, fit_params={ 'eval_set': (X_val, y_val), } ) hyperparam_optimizer.fit(X_train, y_train) return hyperparam_optimizer.best_estimator_ # accuracy score best_estimator = perform_bayes_search(clf, X_train, X_val, y_train, y_val, param_grid, scoring='accuracy') _ = calculate_scores(best_estimator, X_val, y_val) # roc auc score best_estimator = perform_bayes_search(clf, X_train, X_val, y_train, y_val, param_grid, scoring='roc_auc') _ = calculate_scores(best_estimator, X_val, y_val) # f1 score best_estimator = perform_bayes_search(clf, X_train, X_val, y_train, y_val, param_grid, scoring='f1') _ = calculate_scores(best_estimator, X_val, y_val) ###Output Warning: Overfitting detector is active, thus evaluation metric is calculated on every iteration. 'metric_period' is ignored for evaluation metric.
measuring-quantum-volume.ipynb
###Markdown Measuring Quantum Volume Introduction**Quantum Volume (QV)** is a single-number metric that can be measured using a concreteprotocol on near-term quantum computers of modest size. The QV method quantifiesthe largest random circuit of equal width and depth that the computer successfully implements.Quantum computing systems with high-fidelity operations, high connectivity, large calibrated gatesets, and circuit rewriting toolchains are expected to have higher quantum volumes. The Quantum Volume ProtocolA QV protocol (see [1]) consists of the following steps:(We should first import the relevant qiskit classes for the demonstration). ###Code import matplotlib.pyplot as plt from IPython.display import clear_output from tqdm.notebook import tqdm #Import Qiskit classes import qiskit from qiskit import assemble, transpile from qiskit.providers.aer.noise import NoiseModel from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error from qiskit.providers.aer import AerSimulator from qiskit.utils import QuantumInstance #Import the qv function import qiskit.ignis.verification.quantum_volume as qv from qiskit import IBMQ if IBMQ.active_account() is None: IBMQ.load_account() provider = IBMQ.get_provider(hub='ibm-q-kaist', group='internal', project='default') backend = provider.get_backend('ibmq_montreal') # backend = AerSimulator.from_backend(backend) quantum_instance = QuantumInstance(backend=backend, shots=2**13) basis_gates = backend.configuration().basis_gates ###Output _____no_output_____ ###Markdown Step 1: Generate QV sequencesIt is well-known that quantum algorithms can be expressed as polynomial-sized quantum circuits built from two-qubit unitary gates. Therefore, a model circuit consists of $d$ layers of random permutations of the qubit labels, followed by random two-qubit gates (from $SU(4)$). When the circuit width $m$ is odd, one of the qubits is idle in each layer.More precisely, a **QV circuit** with **depth $d$** and **width $m$**, is a sequence $U = U^{(d)}...U^{(2)}U^{(1)}$ of $d$ layers:$$ U^{(t)} = U^{(t)}_{\pi_t(m'-1),\pi_t(m)} \otimes ... \otimes U^{(t)}_{\pi_t(1),\pi_t(2)} $$each labeled by times $t = 1 ... d$ and acting on $m' = 2 \lfloor n/2 \rfloor$ qubits. Each layer is specified by choosing a uniformly random permutation $\pi_t \in S_m$ of the $m$ qubit indicesand sampling each $U^{(t)}_{a,b}$, acting on qubits $a$ and $b$, from the Haar measure on $SU(4)$.In the following example we have 6 qubits Q0,Q1,Q3,Q5,Q7,Q10. We are going to look at subsets up to the full set(each volume circuit will be depth equal to the number of qubits in the subset) ###Code # qubit_lists: list of list of qubit subsets to generate QV circuits qubit_lists = [[0, 1, 2, 3, 5, 8], [0, 1, 2, 3, 5, 8, 11], [0, 1, 2, 3, 5, 8, 11, 14], [0, 1, 2, 3, 5, 8, 11, 14, 13]] # ntrials: Number of random circuits to create for each subset ntrials = 100 ###Output _____no_output_____ ###Markdown We generate the quantum volume sequences. We start with a small example (so it doesn't take too long to run). ###Code import warnings warnings.filterwarnings('ignore') qv_circs, qv_circs_nomeas = qv.qv_circuits(qubit_lists, ntrials) ###Output _____no_output_____ ###Markdown As an example, we print the circuit corresponding to the first QV sequence. Note that the ideal circuits are run on the first n qubits (where n is the number of qubits in the subset). ###Code # pass the first trial of the nomeas through the transpiler to illustrate the circuit #qv_circs_nomeas[0] = qiskit.compiler.transpile(qv_circs_nomeas[0], basis_gates=basis_gates) qv_circs_nomeas[0][0].draw(fold=-1) ###Output _____no_output_____ ###Markdown Step 2: Simulate the ideal QV circuitsThe quantum volume method requires that we know the ideal output for each circuit, so we use the statevector simulator in Aer to get the ideal result. ###Code # sv_sim = qiskit.Aer.get_backend('aer_simulator') sv_sim = QuantumInstance(backend=AerSimulator(), shots=2**13) ideal_results = [] for trial in tqdm(range(ntrials)): # clear_output(wait=True) for qc in qv_circs_nomeas[trial]: qc.save_statevector() #result = qiskit.execute(qv_circs_nomeas[trial], backend=sv_sim).result() result = sv_sim.execute(qv_circs_nomeas[trial]) ideal_results.append(result) # print(f'Simulated trial {trial+1}/{ntrials}') ###Output _____no_output_____ ###Markdown Next, we load the ideal results into a quantum volume fitter ###Code qv_fitter = qv.QVFitter(qubit_lists=qubit_lists) qv_fitter.add_statevectors(ideal_results) ###Output _____no_output_____ ###Markdown Step 3: Calculate the heavy outputsTo define when a model circuit $U$ has been successfully implemented in practice, we use the *heavy output* generation problem. The ideal output distribution is $p_U(x) = |\langle x|U|0 \rangle|^2$, where $x \in \{0,1\}^m$ is an observable bit-string. Consider the set of output probabilities given by the range of $p_U(x)$ sorted in ascending order $p_0 \leq p_1 \leq \dots \leq p_{2^m-1}$. The median of the set of probabilities is $p_{med} = (p_{2^{m-1}} + p_{2^{m-1}-1})/2$, and the *heavy outputs* are$$ H_U = \{ x \in \{0,1\}^m \text{ such that } p_U(x)>p_{med} \}.$$The heavy output generation problem is to produce a set of output strings such that more than two-thirds are heavy.As an illustration, we print the heavy outputs from various depths and their probabilities (for trial 0): ###Code for qubit_list in qubit_lists: l = len(qubit_list) print ('qv_depth_'+str(l)+'_trial_0:', qv_fitter._heavy_outputs['qv_depth_'+str(l)+'_trial_0']) for qubit_list in qubit_lists: l = len(qubit_list) print ('qv_depth_'+str(l)+'_trial_0:', qv_fitter._heavy_output_prob_ideal['qv_depth_'+str(l)+'_trial_0']) exp_results = [] for trial in tqdm(range(ntrials)): #clear_output(wait=True) # t_qcs = transpile(qv_circs[trial], basis_gates=basis_gates, optimization_level=3) # qobj = assemble(t_qcs) # result = backend.run(qobj, max_parallel_experiments=0, shots=2**13).result() result = quantum_instance.execute(qv_circs[trial]) exp_results.append(result) #print(f'Completed trial {trial+1}/{ntrials}') ###Output _____no_output_____ ###Markdown Step 5: Calculate the average gate fidelityThe *average gate fidelity* between the $m$-qubit ideal unitaries $U$ and the executed $U'$ is:$$ F_{avg}(U,U') = \frac{|Tr(U^{\dagger}U')|^2/2^m+1}{2^m+1}$$The observed distribution for an implementation $U'$ of model circuit $U$ is $q_U(x)$, and the probability of samplinga heavy output is:$$ h_U = \sum_{x \in H_U} q_U(x)$$As an illustration, we print the heavy output counts from various depths (for trial 0): ###Code qv_fitter.add_data(exp_results) for qubit_list in qubit_lists: l = len(qubit_list) print ('qv_depth_'+str(l)+'_trial_0:', qv_fitter._heavy_output_counts['qv_depth_'+str(l)+'_trial_0']) ###Output _____no_output_____ ###Markdown Step 6: Calculate the achievable depthThe probability of observing a heavy output by implementing a randomly selected depth $d$ model circuit is:$$h_d = \int_U h_U dU$$The *achievable depth* $d(m)$ is the largest $d$ such that we are confident that $h_d > 2/3$. In other words,$$ h_1,h_2,\dots,h_{d(m)}>2/3 \text{ and } h_{d(m)+1} \leq 2/3$$We now convert the heavy outputs in the different trials and calculate the mean $h_d$ and the error for plotting the graph. ###Code plt.figure(figsize=(10, 6)) ax = plt.gca() # Plot the essence by calling plot_rb_data qv_fitter.plot_qv_data(ax=ax, show_plt=False) # Add title and label ax.set_title('Quantum Volume for up to %d Qubits \n and %d Trials'%(len(qubit_lists[-1]), ntrials), fontsize=18) plt.show() ###Output _____no_output_____ ###Markdown Step 7: Calculate the Quantum VolumeThe quantum volume treats the width and depth of a model circuit with equal importance and measures the largest square-shaped (i.e., $m = d$) model circuit a quantum computer can implement successfully on average. The *quantum volume* $V_Q$ is defined as$$\log_2 V_Q = \arg\max_{m} \min (m, d(m))$$ We list the statistics for each depth. For each depth we list if the depth was successful or not and with what confidence interval. For a depth to be successful the confidence interval must be > 97.5%. ###Code qv_success_list = qv_fitter.qv_success() qv_list = qv_fitter.ydata QV = 1 for qidx, qubit_list in enumerate(qubit_lists): if qv_list[0][qidx]>2/3: if qv_success_list[qidx][0]: print("Width/depth %d greater than 2/3 (%f) with confidence %f (successful). Quantum volume %d"% (len(qubit_list),qv_list[0][qidx],qv_success_list[qidx][1],qv_fitter.quantum_volume()[qidx])) QV = qv_fitter.quantum_volume()[qidx] else: print("Width/depth %d greater than 2/3 (%f) with confidence %f (unsuccessful)."% (len(qubit_list),qv_list[0][qidx],qv_success_list[qidx][1])) else: print("Width/depth %d less than 2/3 (unsuccessful)."%len(qubit_list)) print ("The Quantum Volume is:", QV) ###Output _____no_output_____ ###Markdown References[1] Andrew W. Cross, Lev S. Bishop, Sarah Sheldon, Paul D. Nation, and Jay M. Gambetta, *Validating quantum computers using randomized model circuits*, Phys. Rev. A **100**, 032328 (2019). https://arxiv.org/pdf/1811.12926 ###Code import qiskit.tools.jupyter %qiskit_version_table ###Output _____no_output_____
Sketchify your Photo/src/Activity 2/Activity-2-Invert Image.ipynb
###Markdown Obtain a negative of an ImageA negative of the image can be obtained by "inverting" the grayscale value of every pixel. Since by default grayscale values are represented as integers in the range [0,255] (i.e., precision CV_8U), the "inverse" of a grayscale value x is simply 255-x: There 2 different ways to transform an image to negative using the OpenCV module. The first method explains negative transformation step by step and the second method explains negative transformation of an image in single line.**1st method: Steps for negative transformation**1. Read an image2. Get height and width of the image3. Each pixel contains 3 channels. So, take a pixel value and collect 3 channels in 3 different variables.4. Negate 3 pixels values from 255 and store them again in pixel used before.5. Do it for all pixel values present in image.**2nd method: Steps for negative transformation**1. Read an image and store it in a variable.2. Subtract the variable from 1 and store the value in another variable.3. All done. You successfully done the negative transformation. ###Code #Import the image input/output library ###Output _____no_output_____ ###Markdown Solution ```pythonimport imageio``` ###Code # Read the Image and Covert it to gray scale ###Output _____no_output_____ ###Markdown Solution ```pythons = imageio.imread(img)g=grayscale(s)``` ###Code # Implement basic logic of inverting an image ###Output _____no_output_____
project/Packaging/ModulesAndPackaging_Notes.ipynb
###Markdown Modules and Packaging====At some point, you will want to organize and distribute your code library for the whole world to share, preferably on PyPI so that it is pip installable. ReferencesThis notebook shows a bare-bones version of creating and distributing a project to PyPI. Please follow the instructions in the official documentations. For convenience, you can use the sample project as a template. - [Packaging and Distributing Projects](https://packaging.python.org/tutorials/distributing-packages/)- [A sample Python project](https://github.com/pypa/sampleproject)For more about how to organize the structure of your package - [Official tutorial on packages](https://docs.python.org/3/tutorial/modules.htmlpackages)If you are still confused about what `__init__.py` does, this [blog post](and the mysterious `__init__.py`, see) might help. Install packages we will use for packaging ###Code ! pip install -U pip ! pip install twine ###Output Collecting pip Downloading pip-9.0.3-py2.py3-none-any.whl (1.4MB)  100% |████████████████████████████████| 1.4MB 841kB/s eta 0:00:01 [?25hInstalling collected packages: pip Found existing installation: pip 9.0.1 Uninstalling pip-9.0.1: Successfully uninstalled pip-9.0.1 Successfully installed pip-9.0.3 Collecting twine Downloading twine-1.11.0-py2.py3-none-any.whl Requirement already satisfied: requests!=2.15,!=2.16,>=2.5.0 in /opt/conda/lib/python3.6/site-packages (from twine) Requirement already satisfied: tqdm>=4.14 in /opt/conda/lib/python3.6/site-packages (from twine) Collecting pkginfo>=1.4.2 (from twine) Downloading pkginfo-1.4.2-py2.py3-none-any.whl Requirement already satisfied: setuptools>=0.7.0 in /opt/conda/lib/python3.6/site-packages (from twine) Collecting requests-toolbelt>=0.8.0 (from twine) Downloading requests_toolbelt-0.8.0-py2.py3-none-any.whl (54kB)  100% |████████████████████████████████| 61kB 4.7MB/s ta 0:00:011 [?25hRequirement already satisfied: chardet<3.1.0,>=3.0.2 in /opt/conda/lib/python3.6/site-packages (from requests!=2.15,!=2.16,>=2.5.0->twine) Requirement already satisfied: idna<2.7,>=2.5 in /opt/conda/lib/python3.6/site-packages (from requests!=2.15,!=2.16,>=2.5.0->twine) Requirement already satisfied: urllib3<1.23,>=1.21.1 in /opt/conda/lib/python3.6/site-packages (from requests!=2.15,!=2.16,>=2.5.0->twine) Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.6/site-packages (from requests!=2.15,!=2.16,>=2.5.0->twine) Installing collected packages: pkginfo, requests-toolbelt, twine Successfully installed pkginfo-1.4.2 requests-toolbelt-0.8.0 twine-1.11.0 ###Markdown ModulesIn Pythoh, any `.py` file is a module in that it can be imported. Because the interpreter runs the entrie file when a moudle is imported, it is traditional to use a guard to ignore code that should only run when the file is executed as a script. ###Code %%file foo.py """ When this file is imported with `import foo`, only `useful_func1()` and `useful_func()` are loaded, and the test code `assert ...` is ignored. However, when we run foo.py as a script `python foo.py`, then the two assert statements are run. Most commonly, the code under `if __naem__ == '__main__':` consists of simple examples or test cases for the functions defined in the moule. """ def useful_func1(): pass def useful_fucn2(): pass if __name__ == '__main__': #??? assert(useful_func1() is None) assert(useful_fucn2() is None) ###Output Writing foo.py ###Markdown Organization of files in a moduleWhen the number of files you write grow large, you will probably want to orgnize them into their own directory structure. To make a folder a module, you just need to include a file named `__init__.py` in the folder. This file can be empty. For example, here is a module named `pkg` with sub-modules `sub1` and `sub2`.```./pkg:__init__.py foo.py sub1 sub2./pkg/sub1:__init__.py more_sub1_stuff.py sub1_stuff.py./pkg/sub2:__init__.py sub2_stuff.py``` ###Code import pkg.foo as foo foo.f1() import pkg pkg.foo.f1() ###Output _____no_output_____ ###Markdown How to import a module at the same levelWithin a package, we need to use absolute path names for importing other modules in the same directory. This prevents confusion as to whether you want to import a system moudle with the same name. For example, `foo.sub1.more_sub1_stuff.py` imports functions from `foo.sub1.sub1_stuff.py` ###Code ! cat pkg/sub1/more_sub1_stuff.py from pkg.sub1.more_sub1_stuff import g3 g3() ###Output _____no_output_____ ###Markdown How to import a moudle at a different levelAgain, just use absolute paths. For example, `sub2_stuff.py` in the `sub2` directory uses functions from `sub1_stuff.py` in the `sub1` directory: ###Code ! cat pkg/sub2/sub2_stuff.py from pkg.sub2.sub2_stuff import h2 h2() ###Output _____no_output_____ ###Markdown Distributing your packageSuppose we want to distribute our code as a library (for example, on PyPI so that it cnn be installed with `pip`). Let's create an `sta663-` (the username part is just to avoid name conflicts) library containing the `pkg` package and some other files:- `README.md`: some information about the library- `sta663.py`: a standalone module- `run_sta663.py`: a script (intended for use as `python run_sta663.py`) ###Code ! ls -R sta663 ! cat sta663/run_sta663.py ###Output import pkg.foo as foo from pkg.sub1.more_sub1_stuff import g3 from pkg.sub2.sub2_stuff import h2 print foo.f1() print g3() print h2() ###Markdown Using distutilsAll we need to do is to write a `setup.py` file. ###Code %%file sta663/setup.py from setuptools import setup setup(name = "sta663-cliburn", version = "1.0", author='Cliburn Chan', author_email='[email protected]', url='http://people.duke.edu/~ccc14/sta-663-2018/', py_modules = ['sta663'], packages = ['pkg', 'pkg/sub1', 'pkg/sub2'], scripts = ['run_sta663.py'], python_requires='>=3', ) ###Output Overwriting sta663/setup.py ###Markdown Build a source archive for distribution ###Code %%bash cd sta663 python setup.py sdist cd - ! ls -R sta663 ###Output _____no_output_____ ###Markdown DistributionYou can now distribute `sta663-1.0.tar.gz` to somebody else for installation in the usual way. ###Code %%bash cp sta663/dist/sta663-1.0.tar.gz /tmp cd /tmp tar xzf sta663-1.0.tar.gz cd sta663-1.0 python setup.py install import sta663 from sta663 import pkg pkg.sub1.sub1_stuff.g1() pkg.sub1.sub1_stuff.g2() pkg.sub1.more_sub1_stuff.g3() pkg.sub2.sub2_stuff.h1() pkg.sub2.sub2_stuff.h2() ###Output _____no_output_____ ###Markdown Distributing to PyPIFor testing, please upload to TestPyPI which is cleaned on a regular basis. See instructions at https://packaging.python.org/guides/using-testpypi/using-test-pypi- **Note 1**: You need to confirm your email address after registration.- **Note 2**: You can easily delete any uploaded packages by logging in at https://test.pypi.org.When your package is ready for public release, you can upload to PyPI. See instructions athttps://packaging.python.org/tutorials/distributing-packages/id78 ###Code %%bash export TWINE_USERNAME='' export TWINE_PASSWORD='' twine upload --repository-url https://test.pypi.org/legacy/ sta663/dist/* %%bash pip install --index-url https://test.pypi.org/simple/ sta663 ###Output _____no_output_____
_notebooks/2020-10-22-k_nearest_neighbors.ipynb
###Markdown K-Nearest Neighbors (K-NN)> A tutorial On how to use K-Nearest Neighbours.- toc: true - badges: true- comments: true- categories: [jupyter, Classification] 0. Data Preprocessing 0.1 Importing the libraries ###Code import numpy as np import matplotlib.pyplot as plt import pandas as pd ###Output _____no_output_____ ###Markdown 0.2 Importing the dataset ###Code dataset = pd.read_csv('Social_Network_Ads.csv') dataset ###Output _____no_output_____ ###Markdown 0.3 Check if any null value ###Code dataset.isna().sum() dataset.info() ###Output <class 'pandas.core.frame.DataFrame'> RangeIndex: 400 entries, 0 to 399 Data columns (total 5 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 User ID 400 non-null int64 1 Gender 400 non-null object 2 Age 400 non-null int64 3 EstimatedSalary 400 non-null int64 4 Purchased 400 non-null int64 dtypes: int64(4), object(1) memory usage: 15.8+ KB ###Markdown Drop User ID ###Code dataset.drop('User ID', axis=1, inplace=True) dataset.head() ###Output _____no_output_____ ###Markdown 0.4 Split into X & y ###Code X = dataset.drop('Purchased', axis=1) X.head() y = dataset['Purchased'] y.head() ###Output _____no_output_____ ###Markdown 0.5 Convert categories into numbers ###Code from sklearn.preprocessing import OneHotEncoder from sklearn.compose import ColumnTransformer categorical_feature = ["Gender"] one_hot = OneHotEncoder() transformer = ColumnTransformer([("one_hot", one_hot, categorical_feature)], remainder="passthrough") transformed_X = transformer.fit_transform(X) pd.DataFrame(transformed_X).head() ###Output _____no_output_____ ###Markdown 0.6 Splitting the dataset into the Training set and Test set ###Code from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(transformed_X, y, test_size = 0.25, random_state = 2509) ###Output _____no_output_____ ###Markdown 0.7 Feature Scaling ###Code from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) ###Output _____no_output_____ ###Markdown 1.Training the model on the Training set ###Code from sklearn.neighbors import KNeighborsClassifier classifier = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2) classifier.fit(X_train, y_train) ###Output _____no_output_____ ###Markdown 1.1 Score ###Code classifier.score(X_test,y_test) ###Output _____no_output_____ ###Markdown 2.Predicting the Test set results ###Code y_pred = classifier.predict(X_test) ###Output _____no_output_____ ###Markdown 2.2 Making the Confusion Matrix ###Code from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) print(cm) ###Output [[66 4] [ 3 27]]
MODULO 2/Problema1.ipynb
###Markdown MARIO GAME Implemente un programa que imprima una media pirámide de una altura específica, como se indica a continuación. $ ./marioHeight: 4 Especificaciones - Cree un archivo llamado mario.py,el cual es un programa que recrea una media pirámide usando los hash () para los bloques.- Para hacer las cosas más interesantes, primero solicite al usuario input la altura de la media pirámide, el cual debe ser un número entero positivo entre 1 y 8, inclusive.- Si el usuario no proporciona un número entero positivo no mayor que 8, debe volver a solicitar el mismo.- Luego, genere (con la ayuda de print uno o más bucles) la media pirámide deseada.- Tenga cuidado de alinear la esquina inferior izquierda de su media pirámide con el borde izquierdo de la ventana de su terminal. Uso Su programa debería comportarse según el ejemplo siguiente. $ ./marioHeight: 4 Pruebas - Ejecute su programa como python mario.py y espere una solicitud de entrada. Escribe -1 y presiona enter. Su programa debe rechazar esta entrada como inválida, por ejemplo, volviendo a solicitar al usuario que escriba otro número.- Ejecute su programa como python mario.py y espere una solicitud de entrada. Escribe 0 y presiona enter. Su programa debe rechazar esta entrada como inválida, por ejemplo, volviendo a solicitar al usuario que escriba otro número.- Ejecute su programa como python mario.py y espere una solicitud de entrada. Escribe 1 y presiona enter. Su programa debería generar la siguiente salida. Asegúrese de que la pirámide esté alineada con la esquina inferior izquierda de su terminal y de que no haya espacios adicionales al final de cada línea. Ejecute su programa como python mario.py y espere una solicitud de entrada. Escribe 2 y presiona enter. Su programa debería generar la siguiente salida. Asegúrese de que la pirámide esté alineada con la esquina inferior izquierda de su terminal y de que no haya espacios adicionales al final de cada línea. Ejecute su programa como python mario.py y espere una solicitud de entrada. Escribe 8 y presiona enter. Su programa debería generar la siguiente salida. Asegúrese de que la pirámide esté alineada con la esquina inferior izquierda de su terminal y de que no haya espacios adicionales al final de cada línea. Ejecute su programa como python mario.py y espere una solicitud de entrada. Escribe 9 y presiona enter. Su programa debe rechazar esta entrada como inválida, por ejemplo, volviendo a solicitar al usuario que escriba otro número. Luego, escribe 2 y presiona enter. Su programa debería generar la siguiente salida. Asegúrese de que la pirámide esté alineada con la esquina inferior izquierda de su terminal y de que no haya espacios adicionales al final de cada línea. - Ejecute su programa como python mario.py y espere una solicitud de entrada. Escribe fooy presiona enter. Su programa debe rechazar esta entrada como inválida, por ejemplo, volviendo a solicitar al usuario que escriba otro número.- Ejecute su programa como python mario.py y espere una solicitud de entrada. No escriba nada y presione enter. Su programa debe rechazar esta entrada como inválida, por ejemplo, volviendo a solicitar al usuario que escriba otro número. ###Code numero = int(input('Ingresa un numero')) for triangulo in range(1, numero+1): print(' '*(numero-triangulo)+'#'*triangulo) if numero is str: break ###Output Ingresa un numero 30
workshop-resources/data-science-and-machine-learning/Data_Science_1/bioscience-project/DS1-Instructor.ipynb
###Markdown Exploration: NumPy and PandasA fundamental component of mastering data science concepts is applying and practicing them. This exploratory notebook is designed to provide you with a semi-directed space to do just that with the Python, NumPy, and pandas skills that you either covered in an in-person workshop or through Microsoft Learn. The specific examples in this notebook apply NumPy and pandas concepts in a life-sciences context, but they are applicable across disciplines and industry verticals.This notebook is divided into different stages of exploration. Initial suggestions for exploration are more structured than later ones and can provide some additional concepts and skills for tackling data-science challenges with real-world data. However, this notebook is designed to provide you with a launchpad for your personal experimentation with data science, so feel free to add cells and running your own experiments beyond those suggested here. That is the power and the purpose of a platform like Jupyter notebooks! Setup and Refresher on NotebooksBefore we begin, you will need to important the principal libraries used to explore and manipulate data in Python: NumPy and pandas. The cell below also imports Matplotlib, the main visualization library in Python. For simplicity and consistency with prior instruction, industry-standard aliases are applied to these imported libraries. The cell below also runs `%matplotlib inline` magic command, which instructs Jupyter to display Matplotlib output directly in the notebook. ###Code import numpy as np import pandas as pd import matplotlib.pyplot as plt %matplotlib inline ###Output _____no_output_____ ###Markdown As it might have been a while since you last worked with Jupyter notebooks, here is a quick refresher on efficiently using them. Notebook CellsNotebook cells are divided into Markdown text cells and interactive code cells. You can easily recognize code cells by the `[-]:` to the left of them.Code in a code cells has only been executed -- and is thus available for use in other code cells in the notebook -- if there is a number beside the code cell (for example, `[1]:`).To run the code in a cell, you can click the **Run** icon at the top left of a code cell or press **`Ctrl` + `Enter`**. Instructor's NoteOpen-ended questions for students and groups in this notebook are followed by italicized explanations in your copy of this notebook to more easily help you guide group discussions or answer student questions. Documentation and HelpDocumentation for Python objects and functions is available directly in Jupyter notebooks. In order to access the documentation, simply put a question mark in front of the object or function in a code cell and execute the cell (for example, `?print`). A window containing the documentation will then open at the bottom of the notebook.On to exploration! Section 1: Guided ExplorationFor this workshop, you will step into the role of a data scientist helping researchers examine a new dataset of genetic information. The dataset is entitled `genome.txt`. It contains close to 1 million single-nucleotide polymorphisms (SNPs) from build 36 of the human genome. SNPs are variations of a single nucleotide that occurs at specific positions in a genome and thus serve as useful sign posts for pinpointing susceptibility to diseases and other genetic conditions. As a result, they are particularly useful in the field of bioinformatics.This particular set of SNPs was originally generated by the genomics company 23andME in February 2011 and is drawn from the National Center for Biotechnology Information within the United States National Institutes of Health and is used here as data in the public domain. Import and Investigate the DataRecall that `pd.read_csv()` is the most common way to pull external data into a pandas DataFrame. Despite its name, this function works on a variety of file formats containing delimited data. Go ahead and try it on `genome.txt`.(If you need a refresher on the syntax for using this function, refer back to the Reactor pandas materials, to the build-in Jupyter documentation with `?pd.read_csv`, or to the [pandas documentation](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html).) ###Code # Import the data from genome.txt into a DataFrame. genome = pd.read_csv('Data/genome.txt') genome.head() ###Output _____no_output_____ ###Markdown The \t indicate that the data in this text file is delimited by tabs. Try re-importing this data and this time specify the separator to use. ###Code # Import the data from genome.txt into a DataFrame and specify the separator. genome = pd.read_csv('Data/genome.txt', sep='\t') genome.head() ###Output _____no_output_____ ###Markdown Is the DataFrame now in a more useful form? If so, what initial information can gather about the dataset, such as its features or number of observations? (The [`head()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.head.html) and [`info()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.info.html) methods are some of the tools that you can use for your preliminary investigation of the dataset.) - *The dataset has 966,977 rows and four columns, none of which have missing values. One column (position) has numeric data while the other columns have string data.* ###Code # Use the info() method to print a concise summary of the genome DataFrame. genome.info() ###Output <class 'pandas.core.frame.DataFrame'> RangeIndex: 966977 entries, 0 to 966976 Data columns (total 4 columns): rsid 966977 non-null object chromosome 966977 non-null object position 966977 non-null int64 genotype 966977 non-null object dtypes: int64(1), object(3) memory usage: 29.5+ MB ###Markdown Interpreting the Dataset**`rsid`** is short for Reference SNP cluster ID; it is the identification number used by researchers and in databases to refer to specific SNPs. (For more information, see the [23andMe](https://customercare.23andme.com/hc/en-us/articles/212196908-What-Are-RS-Numbers-Rsid-) reference page on RS numbers.**`chromosome`** refers to which of the 23 human chromosomes (22 numbered and one X or Y chromosome) or the mitochondrial chromosoe on which an SNP appears.**`position`** refers to the specific location of a given SNP on the reference human genome. (For more information on the reference human genome, see the [human genome overview page](https://www.ncbi.nlm.nih.gov/grc/human) on the Genome Reference Consortium web site.) **`genotype`** refers to the pair of nucleotides that form an SNP inherited at a given chromosomal position (one coming from the father and one coming from the mother). (For more information on genotypes -- as well as a list of notable genotypes -- visit the [genotype page](https://www.snpedia.com/index.php/Genotype) at SNPedia.) Section 2: Intermediate ExplorationNow that you know more about the dataset, the next step is to start asking questions of it. A common next attribute of this particular dataset to investigate is how many SNPs occur per chromosome. Use the `value_counts()` method to determine this.(**Note:** You might also find it helpful to refer back to the Reactors pandas material to work through this section.) ###Code # Use the value_counts() method to find the counts of unique values in the chromosome column. genome['chromosome'].value_counts() ###Output _____no_output_____ ###Markdown Numbers are good for precision, but often a visualization can provide a more succinct (and digestible) presentation of data. The `plot()` method is a convenient way to invoke Matplotlib directly from your DataFrame. Use the `plot()` method to creat a bar chart of of the SNP value counts per chromosome. (**Hint:** You can do this either by specifying the `kind` argument in the `plot()` method or by using the `plot.bar()` method.) ###Code # Plot the value counts for the unique values in the chromosome column. genome['chromosome'].value_counts().plot(kind='bar'); ###Output _____no_output_____ ###Markdown The `value_counts()` method automatically sorts the chromosomes highest occurrence of SNPs to the lowest. However, because we are exploring data related to the different chromosomes, viewing the data sorted by the order in which chromosomes appear in the dataset can be more useful the researchers you are helping. Try to see if you can figure out how to do so. (The `sort_index()` method is one possibility. Another possibility gets raised in the comments in this Stack Overflow [article](https://stackoverflow.com/questions/43855474/changing-sort-in-value-counts).) ###Code # Print the value counts for the unique values in the chromosome column in the order in which they occur. genome['chromosome'].value_counts()[genome['chromosome'].unique()] ###Output _____no_output_____ ###Markdown Now try plotting this output. (One of the joys of pandas is that you can continue to string methods to objects in order to generate powerful, compact code.) ###Code # Plot the value counts for the unique values in the chromosome column in the order in which they occur. genome['chromosome'].value_counts()[genome['chromosome'].unique()].plot(kind='bar'); ###Output _____no_output_____ ###Markdown Grouping DataThus far we have only looked at one column of the DataFrame, `chomosome`. However, pandas provides tools to quickly examine more of the DataFrame at once. If you haven't tried it already, the `groupby()` method can be useful in situations like this to turn the values of one of the columns in a DataFrame into the index for the DataFrame. Try using that method using the `chromosome` column coupled with the `count()` method. ###Code # Use the groupby() and count() methods to create a DataFrame of grouped values. genome.groupby('chromosome').count() ###Output _____no_output_____ ###Markdown You can also plot your now-grouped DataFrame. (**Note:** Your bar graph might not turn out the way you expected. If so, discuss with your partner or group what might solve this problem.) - *If you do not specify a column within the grouped DataFrame to plot, Python will plot all three columns for each chomosome.* ###Code # Plot the unique genotype counts from the grouped chromosome DataFrame. genome.groupby('chromosome')['genotype'].count().plot(kind='bar'); ###Output _____no_output_____ ###Markdown Changing what you group by is another means of asking questions about your data. Now try grouping by `genotype`. What does this new grouping tell you? - *The SNPs in this dataset appear most frequenly on certain genotypes.* ###Code # Plot the unique chromosome counts from the grouped genotype DataFrame. genome.groupby('genotype')['chromosome'].count().plot.bar(); ###Output _____no_output_____ ###Markdown **Note:** The **D** and **DD** are not nucleotides themselves; DNA nucleotides can only be adenine (A), thymine (T), guanine (G) and cytosine (C). Rather, the **D** stands for genotypes in which in which one or more base pairs (or even an entire part of a chromosome) has been **deleted** during DNA replication.Similarly, **I** and **II** represent genotypes of [wobble base pairs](https://en.wikipedia.org/wiki/Wobble_base_pair) that do not do not follow the conventional A-T and C-G pairing in DNA. Such genotypes are responsible for ailments such as [sickle-cell disease](https://en.wikipedia.org/wiki/Sickle_cell_disease). Pivoting DataYou can summarize your DataFrame in a fashion similar to pivot tables in spreadsheets by use of the [`pivot()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.pivot.html) function. Try using this function on your grouped data, but be advised that the `index`, `columns`, and `values` arguments for this function all require `str` or `object` inputs, so it might be easiest to first capture the output from the `groupby()` in a new DataFrame. (This Stack Overflow [answer](https://stackoverflow.com/questions/10373660/converting-a-pandas-groupby-output-from-series-to-dataframe) given by Wes McKinney, the creator of pandas, might prove useful in doing this.) ###Code # Created a DataFrame by grouping the genome data by both genotype and chromosome. grouped_genome = genome.groupby(['genotype', 'chromosome'])['rsid'].count().reset_index() # Rename the rsid column to count as this is the role that this column will fill in this new DataFrame. grouped_genome.rename(columns={'rsid': 'count'}, inplace=True) grouped_genome.head() # Create a pivoted DataFrame with genotype as the index, chromosome as the columns, and count as the values. pivot_genome = grouped_genome.pivot(index='genotype', columns='chromosome', values='count') pivot_genome.head() ###Output _____no_output_____ ###Markdown Stacked Bar GraphWith the data pivoted, you can try somewhat more advanced visualization of your data such as a stacked bar graph in which you can see not just how many instances of different genotypes there are in the dataset, but also how many of those instances occur on each chromosome. This can be useful to helping your researchers understand the dataset in that they are not only interested in the number of genotype occurences, but also on which chromosomes they occur. Build upon what you know about visualiziing with Matplotlib and refer to the documentation for more hints about how to execute this. ###Code # Plot the pivoted DataFrame to create a stacked barchart. pivot_genome.plot.bar(stacked=True, figsize=(10,7)); # Access the documentation for the bar function from within Jupyter. ?pivot_genome.plot.bar ###Output Signature: pivot_genome.plot.bar(x=None, y=None, **kwds) Docstring: Vertical bar plot. A bar plot is a plot that presents categorical data with rectangular bars with lengths proportional to the values that they represent. A bar plot shows comparisons among discrete categories. One axis of the plot shows the specific categories being compared, and the other axis represents a measured value. Parameters ---------- x : label or position, optional Allows plotting of one column versus another. If not specified, the index of the DataFrame is used. y : label or position, optional Allows plotting of one column versus another. If not specified, all numerical columns are used. **kwds Additional keyword arguments are documented in :meth:`pandas.DataFrame.plot`. Returns ------- axes : matplotlib.axes.Axes or np.ndarray of them An ndarray is returned with one :class:`matplotlib.axes.Axes` per column when ``subplots=True``. See Also -------- pandas.DataFrame.plot.barh : Horizontal bar plot. pandas.DataFrame.plot : Make plots of a DataFrame. matplotlib.pyplot.bar : Make a bar plot with matplotlib. Examples -------- Basic plot. .. plot:: :context: close-figs >>> df = pd.DataFrame({'lab':['A', 'B', 'C'], 'val':[10, 30, 20]}) >>> ax = df.plot.bar(x='lab', y='val', rot=0) Plot a whole dataframe to a bar plot. Each column is assigned a distinct color, and each row is nested in a group along the horizontal axis. .. plot:: :context: close-figs >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = pd.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> ax = df.plot.bar(rot=0) Instead of nesting, the figure can be split by column with ``subplots=True``. In this case, a :class:`numpy.ndarray` of :class:`matplotlib.axes.Axes` are returned. .. plot:: :context: close-figs >>> axes = df.plot.bar(rot=0, subplots=True) >>> axes[1].legend(loc=2) # doctest: +SKIP Plot a single column. .. plot:: :context: close-figs >>> ax = df.plot.bar(y='speed', rot=0) Plot only selected categories for the DataFrame. .. plot:: :context: close-figs >>> ax = df.plot.bar(x='lifespan', rot=0) File: c:\users\jeppesen\appdata\local\continuum\anaconda3\lib\site-packages\pandas\plotting\_core.py Type: method ###Markdown Section 3: Individual ExplorationThere is still a lot you can do with this dataset or related ones. Ideas include: - Moving the legend for the stacked bar graph off to one side. This will make the visualization easier to read and more useful to the researchers. ###Code # Students can play with settings like bbox_to_anchor to arrive at an appearance they like. fig = plt.figure() # Create an Axis class object for the stacked barchart. ax = pivot_genome.plot.bar(stacked=True, figsize=(10,7)) # Specify values for the loc and bbox_to_anchor paramaters of the legend() method in order to render the legend to the side. ax.legend(loc='upper center', bbox_to_anchor=(1.09, 1.014), ncol=1) plt.show(); ###Output _____no_output_____ ###Markdown - Researching the average number of base pairs per human chromosome to see (and visualize) what proportion of each chromosome is represented in this dataset. Comparisons of this sort can help researchers quickly see what is out of the ordinary in a dataset such as this one. ###Code # Create a new DataFrame to house the aggregated genotype totals by chromosome. chrom_num = genome.groupby('chromosome')['genotype'].count().reset_index() chrom_num.tail(10) # It is subtle, but there are actually two rows for Chromosome 21. # Combine the genotype totals for both rows and delete the surplus row. chrom_num.iloc[20, 1] = chrom_num.iloc[20, 1] + chrom_num.iloc[21, 1] chrom_num.drop([21], axis=0, inplace=True) chrom_num.reset_index(inplace=True, drop=True) chrom_num.tail(10) # Now make the chromosome number the index for the DataFrame. chrom_num.set_index('chromosome', inplace=True) chrom_num.tail() # Looked up number of base pairs per chromosome from https://ghr.nlm.nih.gov/chromosome # and https://www.nature.com/scitable/topicpage/mtdna-and-mitochondrial-diseases-903/. # Add these numbers as a new column to the DataFrame. mil_base_pairs = [249, 243, 198, 191, 181, 171, 159, 146, 141, 133, 135, 134, 115, 107, 102, 90, 83, 78, 59, 63, 48, 51, 0.017, 155, 59] chrom_num['million base pairs'] = mil_base_pairs chrom_num.head() # Find the proportion that the number of genotypes represents for each chromosome. chrom_num['proportion'] = chrom_num['genotype'].divide(chrom_num['million base pairs']).divide(1000000) chrom_num.tail() # Now normalize the proportions of genotypes and basepairs based on the column totals to graph. chrom_num['gt_proportion'] = chrom_num['genotype'].divide(chrom_num['genotype'].sum()) chrom_num['bp_proportion'] = chrom_num['proportion'].divide(chrom_num['proportion'].sum()) chrom_num.tail() # Graph just the 'gt_proportion' and 'bp_proportion'. chrom_num[['gt_proportion', 'bp_proportion']].plot(kind='bar'); # Mitochondrial genotypes are ridiculously overrepresented in the data. # Remove that row and recompute to see how the other chromosomes stacked up. chrom_num.drop(['MT'], axis=0, inplace=True) chrom_num['proportion'] = chrom_num['genotype'].divide(chrom_num['million base pairs']).divide(1000000) chrom_num['gt_proportion'] = chrom_num['genotype'].divide(chrom_num['genotype'].sum()) chrom_num['bp_proportion'] = chrom_num['proportion'].divide(chrom_num['proportion'].sum()) chrom_num.tail() # No regraph the two columns of interest from the DataFrame. # Genotypes on the lower-numbered chromosomes are far overrepresented a proporition to the size of those chromosomes. chrom_num[['gt_proportion', 'bp_proportion']].plot(kind='bar'); ###Output _____no_output_____
3 - Internal evaluation.ipynb
###Markdown Performance evaluation on complete data ###Code # Performance measures ytrue = [int(v) for v in test_data[test_data.columns[0]].values] probs = model.predict(xtest) ypred = [int(0.5 < p) for p in probs] auc = roc_auc_score(ytrue, probs) fpr, tpr, thresholds = roc_curve(ytrue, probs) brier = brier_score_loss(ytrue, probs) cal, dis = caldis(ytrue, probs) acc = accuracy_score(ytrue, ypred) precision, recall, f1score, support = precision_recall_fscore_support(ytrue, ypred) conf = confusion_matrix(ytrue, ypred) P = N = 0 TP = TN = 0 FP = FN = 0 for i in range(len(ytrue)): if ytrue[i] == 1: P += 1 if ypred[i] == 1: TP += 1 else: FN += 1 else: N += 1 if ypred[i] == 0: TN += 1 else: FP += 1 sens = float(TP)/P spec = float(TN)/N # Positive and Negative Predictive Values # https://en.wikipedia.org/wiki/Positive_and_negative_predictive_values ppv = float(TP) / (TP + FP) npv = float(TN) / (TN + FN) # Likelihood ratios # https://en.wikipedia.org/wiki/Likelihood_ratios_in_diagnostic_testing lr_pos = sens / (1 - spec) if spec < 1 else np.inf lr_neg = (1 - sens) / spec if 0 < spec else np.inf # for i in range(len(ytrue)): # print i, probs[i], ypred[i], ytrue[i] # print "True outcomes:", ytrue # print "Prediction :", ypred print "Number of cases:", len(ytrue) print "CFR :", 100 * (float(np.sum(ytrue)) / len(ytrue)) print "" print "Measures of performance" print "AUC :", auc print "Brier :", brier print "Calibration :", cal print "Discrimination:", dis print "Accuracy :", acc print "Sensitivity :", sens print "Specificity :", spec print "PPV :", ppv print "NPV :", npv print "LR+ :", lr_pos print "LR- :", lr_neg with open(os.path.join(model_name, 'internal-eval.txt'), 'w') as of: of.write("Measures of performance\n") of.write("AUC : " + str(auc) + "\n") of.write("Brier : " + str(brier) + "\n") of.write("Calibration : " + str(cal) + "\n") of.write("Discrimination: " + str(dis) + "\n") of.write("Accuracy : " + str(acc) + "\n") of.write("Sensitivity : " + str(sens) + "\n") of.write("Specificity : " + str(spec) + "\n") of.write("Sensitivity : " + str(sens) + "\n") of.write("Specificity : " + str(spec) + "\n") of.write("PPV : " + str(ppv) + "\n") of.write("NPV : " + str(npv) + "\n") of.write("LR+ : " + str(lr_pos) + "\n") of.write("LR- : " + str(lr_neg) + "\n") # ROC plot fpr, tpr, thresholds = roc_curve(ytrue, probs) fig, ax = plt.subplots() plt.xlim([-0.1, 1.1]) plt.ylim([-0.1, 1.1]) plt.plot([0, 1], [0, 1], 'k--', c='grey') plt.plot(fpr, tpr, color='black') plt.xlabel('1 - Specificity') plt.ylabel('Sensitivity') fig.savefig(os.path.join(model_name, 'internal-roc-complete.pdf')) # Calibration plot cal_table = calibration_table(ytrue, probs, 10) fig, ax = plt.subplots() plt.plot([0.05, 0.95], [0.05, 0.95], '-', c='grey', linewidth=0.5, zorder=1) plt.xlim([-0.1, 1.1]) plt.ylim([-0.1, 1.1]) plt.xlabel('Predicted Risk') plt.ylabel('Observed Risk') x = cal_table['pred_prob'] y = cal_table['true_prob'] # f = interp1d(x, y, kind='cubic') # xnew = np.linspace(min(x), max(x), num=50, endpoint=True) # plt.plot(xnew, f(xnew)) plt.plot(x, y, color='black') fig.savefig(os.path.join(model_name, 'internal-cal-complete.pdf')) # Sensitivity/specificity for an entire range of thresholds ncells = 20 thresholds = np.linspace(0.0, 1.0, ncells + 1) ytrue = [int(v) for v in test_data[test_data.columns[0]].values] x = test_data[test_data.columns[1:]].values probs = model.predict(x) nt = len(thresholds) - 1 interval = [str(t) + "-" + str(t + 1.0/ncells) for t in thresholds[:-1]] sensitivity = [[] for n in range(0, nt)] specificity = [[] for n in range(0, nt)] surv_count = [[] for n in range(0, nt)] died_count = [[] for n in range(0, nt)] for n in range(0, nt): t = thresholds[n] t1 = thresholds[n + 1] ypred = [int(t < p) for p in probs] in_cell = [t < p and p <= t1 for p in probs] nsurv = 0 ndied = 0 P = N = 0 TP = TN = 0 for i in range(len(ytrue)): if ytrue[i] == 1: P += 1 if ypred[i] == 1: TP += 1 if in_cell[i]: ndied += 1 else: N += 1 if ypred[i] == 0: TN += 1 if in_cell[i]: nsurv += 1 sens = float(TP)/P spec = float(TN)/N sensitivity[n].append(sens) specificity[n].append(spec) surv_count[n].append(nsurv) died_count[n].append(ndied) sensitivity = [np.mean(sensitivity[n]) for n in range(0, nt)] specificity = [np.mean(specificity[n]) for n in range(0, nt)] surv_count = [np.mean(surv_count[n]) for n in range(0, nt)] died_count = [np.mean(died_count[n]) for n in range(0, nt)] dfcomp = pd.DataFrame({'Threshold':pd.Series(np.array(thresholds[:-1] + 1.0/ncells)), 'Sensitivity':pd.Series(np.array(sensitivity)), 'Specificity':pd.Series(np.array(specificity)), 'Survival':pd.Series(np.array(surv_count)), 'Mortality':pd.Series(np.array(died_count))}, columns=['Threshold', 'Sensitivity', 'Specificity', 'Survival', 'Mortality']) dfcomp.to_csv(os.path.join(model_name, 'sens-spec-complete.csv')) create_plots(model_name, dfcomp, low_thres, med_thres, 'complete') ###Output Low 29% 18/62 CFR=0% Medium 46% 29/62 CFR=17% High 24% 15/62 CFR=60% ###Markdown Calculations and plots on imputed data ###Code # Odd-ratios with 95% CI ci_critical_value = 1.96 # For 95% CI boot_folder = os.path.join(model_name, 'boot') imp_folder = os.path.join(model_name, 'imp') odds_values = {} data_files = glob.glob(imp_folder + '/imputation-*.csv') for fn in data_files: dat = pd.read_csv(fn, na_values="\\N")[variables] val = dat[dat.columns[1:]].values pos0 = fn.index("imputation-") + 11 pos1 = fn.index(".csv") idx = fn[pos0:pos1] odds_boot = {} index_files = glob.glob(boot_folder + '/index-' + idx + '-*.txt') model_files = glob.glob(boot_folder + '/model-' + idx + '-*.txt') nboot = len(index_files) for b in range(0, nboot): rows = [] with open(index_files[b]) as ifile: lines = ifile.readlines() for line in lines: pieces = line.split()[1:] rows += [int(i) - 1 for i in pieces] model = LogRegModel(model_files[b], model_format='GLM') model.loadVarTypes(isth_data_file, isth_dict_file) odds = model.getOddRatios(xtest) for k in odds: if not k in odds_boot: odds_boot[k] = 0 odds_boot[k] += odds[k] for k in odds_boot: odds_boot[k] = odds_boot[k] / nboot for k in odds_boot: if not k in odds_values: odds_values[k] = [] if 0 < odds_boot[k] and odds_boot[k] < 100: odds_values[k] = odds_values[k] + [odds_boot[k]] # Loading the model's odds odds_model = {} with open(model_oddratios) as f: lines = f.readlines() for line in lines: pieces = line.split() odds_model[pieces[0]] = pieces[1] # Adding the CIs to the model's file with open(model_oddratios, 'w') as f: for k in odds_values: mean_odds = np.mean(odds_values[k]) std_odds = np.std(odds_values[k]) ci_odds = [mean_odds - ci_critical_value * std_odds, mean_odds + ci_critical_value * std_odds] odds_model[k] = odds_model[k] + ' (' + str(ci_odds[0]) + ', ' + str(ci_odds[1]) + ')' print k, odds_model[k] f.write(k + ' ' + odds_model[k] + '\n') # Averaged ROC curve ci_critical_value = 1.96 # For 95% CI boot_folder = os.path.join(model_name, 'boot') imp_folder = os.path.join(model_name, 'imp') fig, ax = plt.subplots() plt.xlim([-0.2, 1.1]) plt.ylim([-0.1, 1.1]) plt.plot([0, 1], [0, 1], 'k--', c='grey', linewidth=0.5) plt.xlabel('1 - Specificity') plt.ylabel('Sensitivity') data_files = glob.glob(imp_folder + '/imputation-*.csv') imp_fpr = [] imp_tpr = [] auc_values = [] for fn in data_files: dat = pd.read_csv(fn, na_values="\\N")[variables] val = dat[dat.columns[1:]].values pos0 = fn.index("imputation-") + 11 pos1 = fn.index(".csv") idx = fn[pos0:pos1] index_files = glob.glob(boot_folder + '/index-' + idx + '-*.txt') model_files = glob.glob(boot_folder + '/model-' + idx + '-*.txt') # Micro-averaging the ROC curves from bootstrap samples: # http://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html ytrue = [] probs = [] ypred = [] nboot = len(index_files) for b in range(0, nboot): rows = [] with open(index_files[b]) as ifile: lines = ifile.readlines() for line in lines: pieces = line.split()[1:] rows += [int(i) - 1 for i in pieces] ytrue += [int(v) for v in dat[dat.columns[0]].values[rows]] x = val[rows,:] model = LogRegModel(model_files[b], model_format='GLM') pboot = model.predict(x) probs += list(pboot) ypred += [int(0.5 < p) for p in pboot] auc = roc_auc_score(ytrue, probs) fpr, tpr, thresholds = roc_curve(ytrue, probs) plt.plot(fpr, tpr, color='black', alpha=0.05) imp_fpr += [fpr] imp_tpr += [tpr] auc_values += [auc] # Macro-average of ROC cuve over all imputations. # First aggregate all false positive rates all_fpr = np.unique(np.concatenate(imp_fpr)) # Then interpolate all ROC curves at this points mean_tpr = np.zeros_like(all_fpr) for i in range(0, len(imp_fpr)): mean_tpr += interp(all_fpr, imp_fpr[i], imp_tpr[i]) mean_tpr /= len(imp_fpr) # mean_auc = metrics.auc(all_fpr, mean_tpr) mean_auc = np.mean(auc_values) std_auc = np.std(auc_values) ci_auc = [mean_auc - ci_critical_value * std_auc, mean_auc + ci_critical_value * std_auc] print "Mean AUC:", mean_auc print "95% CI:", ci_auc with open(os.path.join(model_name, 'average-roc-bootstrap.txt'), 'w') as f: f.write(str(mean_auc) + ' (' + str(ci_auc[0]) + ',' + str(ci_auc[1]) +')') plt.plot(all_fpr, mean_tpr, color='red', alpha=1.0) fig.savefig(os.path.join(model_name, 'average-roc-bootstrap.pdf')) # Average calibration plot boot_folder = os.path.join(model_name, 'boot') imp_folder = os.path.join(model_name, 'imp') fig, ax = plt.subplots() # plt.plot([0, 1], [0, 1], '-', c='grey', linewidth=0.8 * 1, zorder=1) plt.plot([0.05, 0.95], [0.05, 0.95], '-', c='grey', linewidth=0.5, zorder=1) plt.xlim([-0.1, 1.1]) plt.ylim([-0.1, 1.1]) plt.xlabel('Predicted Risk') plt.ylabel('Observed Risk') # lgnd = plt.legend(loc='lower right', scatterpoints=1, fontsize=10) data_files = glob.glob(imp_folder + '/imputation-*.csv') imp_ppr = [] imp_tpr = [] cal_values = [] for fn in data_files: dat = pd.read_csv(fn, na_values="\\N")[variables] val = dat[dat.columns[1:]].values pos0 = fn.index("imputation-") + 11 pos1 = fn.index(".csv") idx = fn[pos0:pos1] index_files = glob.glob(boot_folder + '/index-' + idx + '-*.txt') model_files = glob.glob(boot_folder + '/model-' + idx + '-*.txt') ytrue = [] probs = [] ypred = [] nboot = len(index_files) for b in range(0, nboot): rows = [] with open(index_files[b]) as ifile: lines = ifile.readlines() for line in lines: pieces = line.split()[1:] rows += [int(i) - 1 for i in pieces] ytrue += [int(v) for v in dat[dat.columns[0]].values[rows]] x = val[rows,:] model = LogRegModel(model_files[b], model_format='GLM') pboot = model.predict(x) probs += list(pboot) ypred += [int(0.5 < p) for p in pboot] cal_table = calibration_table(ytrue, probs, 10) cal_values += [np.sqrt(calibration2(ytrue, probs, 10))] # sizes = cal_table['count'] / 20 # plt.scatter(cal_table['pred_prob'], cal_table['true_prob'], s=sizes, c='red', marker='o', lw = 0, alpha=0.8, zorder=2) x = cal_table['pred_prob'] y = cal_table['true_prob'] f = interp1d(x, y, kind='cubic') xnew = np.linspace(min(x), max(x), num=50, endpoint=True) plt.plot(xnew, f(xnew), color='black', alpha=0.1) imp_ppr += [x] imp_tpr += [y] all_ppr = np.unique(np.concatenate(imp_ppr)) mean_tpr = np.zeros_like(all_ppr) for i in range(0, len(imp_ppr)): mean_tpr += interp(all_ppr, imp_ppr[i], imp_tpr[i]) mean_tpr /= len(imp_ppr) # Won't use the mean of the cal_values obtaned from each bootstrap sample because they have, in general, # non-uniform occupancy of the bins, so this result in abnormally low estimates of calibration, specially # if those with high discrepancies between # Aggregating all predictions allow to have good occupancy, but the calibration calculation is done within # each boostrap, so we just use the average results for the predicted and true probabilities. Also, we take # the square root of the calibration, so it really represents the average difference between both curves # v = np.array(all_ppr - mean_tpr) # mean_cal = np.sqrt(np.mean(v * v)) # print "Mean calibration:", mean_cal mean_cal = np.mean(cal_values) std_cal = np.std(cal_values) ci_cal = [mean_cal - ci_critical_value * std_cal, mean_cal + ci_critical_value * std_cal] print "Mean calibration:", mean_cal print "95% CI:", ci_cal with open(os.path.join(model_name, 'average-calibration-bootstrap.txt'), 'w') as f: f.write(str(mean_cal) + ' (' + str(ci_cal[0]) + ',' + str(ci_cal[1]) +')') xnew = np.linspace(min(all_ppr), max(all_ppr), num=2 * len(all_ppr), endpoint=True) f = interp1d(all_ppr, mean_tpr, kind='cubic') plt.plot(xnew, f(xnew), color='red', alpha=1.0) fig.savefig(os.path.join(model_name, 'average-calibration-bootstrap.pdf')) # Final performance figures for paper ncells = 20 thresholds = np.linspace(0.0, 1.0, ncells + 1) nt = len(thresholds) - 1 sensitivity = [[] for n in range(0, nt)] specificity = [[] for n in range(0, nt)] surv_count = [[] for n in range(0, nt)] died_count = [[] for n in range(0, nt)] boot_folder = os.path.join(model_name, 'boot') imp_folder = os.path.join(model_name, 'imp') data_files = glob.glob(imp_folder + '/imputation-*.csv') imp_ppr = [] imp_tpr = [] for fn in data_files: dat = pd.read_csv(fn, na_values="\\N")[variables] val = dat[dat.columns[1:]].values pos0 = fn.index("imputation-") + 11 pos1 = fn.index(".csv") idx = fn[pos0:pos1] index_files = glob.glob(boot_folder + '/index-' + idx + '-*.txt') model_files = glob.glob(boot_folder + '/model-' + idx + '-*.txt') ytrue = [] probs = [] ypred = [] nboot = len(index_files) for b in range(0, nboot): rows = [] with open(index_files[b]) as ifile: lines = ifile.readlines() for line in lines: pieces = line.split()[1:] rows += [int(i) - 1 for i in pieces] ytrue = [int(v) for v in dat[dat.columns[0]].values[rows]] x = val[rows,:] model = LogRegModel(model_files[b], model_format='GLM') probs = model.predict(x) for n in range(0, nt): t = thresholds[n] t1 = thresholds[n + 1] ypred = [int(t < p) for p in probs] in_cell = [t < p and p <= t1 for p in probs] nsurv = 0 ndied = 0 P = N = 0 TP = TN = 0 for i in range(len(ytrue)): if ytrue[i] == 1: P += 1 if ypred[i] == 1: TP += 1 if in_cell[i]: ndied += 1 else: N += 1 if ypred[i] == 0: TN += 1 if in_cell[i]: nsurv += 1 sens = float(TP)/P spec = float(TN)/N sensitivity[n].append(sens) specificity[n].append(spec) surv_count[n].append(nsurv) died_count[n].append(ndied) sensitivity = [np.mean(sensitivity[n]) for n in range(0, nt)] specificity = [np.mean(specificity[n]) for n in range(0, nt)] surv_count = [np.mean(surv_count[n]) for n in range(0, nt)] died_count = [np.mean(died_count[n]) for n in range(0, nt)] dfboot = pd.DataFrame({'Threshold':pd.Series(np.array(thresholds[:-1] + 1.0/ncells)), 'Sensitivity':pd.Series(np.array(sensitivity)), 'Specificity':pd.Series(np.array(specificity)), 'Survival':pd.Series(np.array(surv_count)), 'Mortality':pd.Series(np.array(died_count))}, columns=['Threshold', 'Sensitivity', 'Specificity', 'Survival', 'Mortality']) dfboot.to_csv(os.path.join(model_name, 'sens-spec-bootstrap.csv')) create_plots(model_name, dfboot, low_thres, med_thres, 'bootstrap', mean_auc, mean_cal) ###Output Low 30% 32/105 CFR=2% Medium 40% 42/105 CFR=14% High 29% 31/105 CFR=59%
semana_2/dia_1/.ipynb_checkpoints/RESU_Ejercicios Colecciones-checkpoint.ipynb
###Markdown Ejercicio 1Dada la siguiente lista:> ```ejer_1 = [1,2,3,4,5]```Inviertela par que quede de la siguiente manera> ```ejer_1 = [5,4,3,2,1]``` ###Code ejer_1 = [1,2,3,4,5] ejer_1.reverse() print(ejer_1) ###Output [5, 4, 3, 2, 1] ###Markdown Ejercicio 2Eleva todos los elementos de la lista al cuadrado> ```ejer_2 = [1,2,3,4,5]``` ###Code ejer_2 = [1,2,3,4,5] for i in range(len(ejer_2)): ejer_2[i] = ejer_2[i]**2 print(ejer_2) ###Output [1, 4, 9, 16, 25] ###Markdown Ejercicio 3Crea una lista nueva con todas las combinaciones de las siguientes os listas:> ```ejer_3_1 = ["Hola", "amigo"]```>> ```ejer_3_2 = ["Que", "tal"]```Obten el siguiente output:['Hola Que', 'Hola tal', 'amigo Que', 'amigo tal'] ###Code ejer_3_1 = ["Hola", "amigo"] ejer_3_2 = ["Que", "tal"] ejer_3_tot = [] for i in ejer_3_1: for j in ejer_3_2: ejer_3_tot.append(i + " " + j) print(ejer_3_tot) ###Output ['Hola Que', 'Hola tal', 'amigo Que', 'amigo tal'] ###Markdown Ejercicio 4Dada la siguiente lista, encuentra el valor 45, sustituyelo por el 0> ```ejer_4 = [20, 47, 19, 29, 45, 67, 78, 90]``` ###Code ejer_4 = [20, 47, 19, 29, 45, 67, 78, 90] print(ejer_4) indice = ejer_4.index(45) ejer_4[indice] = 0 print(ejer_4) ###Output [20, 47, 19, 29, 45, 67, 78, 90] [20, 47, 19, 29, 0, 67, 78, 90] ###Markdown Ejercicio 5Dada la siguiente lista, elimina todos los valores iguales a 3> ```ejer_5 = [3, 20, 3, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3]``` ###Code ejer_5 = [3, 20, 3, 47, 19, 3, 3, 29, 45, 67, 78, 90, 3, 3] for i in ejer_5: print(i) print(ejer_5) if i == 3: ejer_5.remove(3) #print(ejer_5) print(ejer_5) ###Output 3 [3, 20, 3, 47, 19, 3, 3, 29, 45, 67, 78, 90, 3, 3] 3 [20, 3, 47, 19, 3, 3, 29, 45, 67, 78, 90, 3, 3] 19 [20, 47, 19, 3, 3, 29, 45, 67, 78, 90, 3, 3] 3 [20, 47, 19, 3, 3, 29, 45, 67, 78, 90, 3, 3] 29 [20, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3] 45 [20, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3] 67 [20, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3] 78 [20, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3] 90 [20, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3] 3 [20, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3] [20, 47, 19, 29, 45, 67, 78, 90, 3, 3] ###Markdown Ejercicio 61. Crea una tupla con 3 elementos2. Crea otra tupla con un elemento y comprueba su tipo3. Crea una tupla con elementos de diferentes tipos4. Imprime por pantalla el primer y ultimo elemento de la tupla del apartado 3. Usa `len` para el ultimo5. Añade un elemento a la tupla del apartado 3.6. Eliminar un elemento de la tupla del apartado 5, que se encuentre más o menos en la mitad.7. Convierte la tupla del apartado 5 en una lista ###Code # Apartado 1 ejer_6_1 = (1,2,3) print(ejer_6_1) # Apartado 2 ejer_6_2 = (4,) print(ejer_6_2) print(type(ejer_6_2)) # Apartado 3 ejer_6_3 = ("a", 5, True, 7.) print(ejer_6_3) # Apartado 4 print(ejer_6_3[0]) print(ejer_6_3[len(ejer_6_3)-1]) # Apartado 5 ejer_6_5 = (8,) ejer_6_5_1 = ejer_6_3 + ejer_6_5 print(ejer_6_5_1) # Apartado 6 ejer_6_1 = ejer_6_5_1[0:2] ejer_6_2 = ejer_6_5_1[3:5] print(ejer_6_1 + ejer_6_2) # Apartado 7 print(list(ejer_6_5_1)) ###Output (1, 2, 3) (4,) <class 'tuple'> ('a', 5, True, 7.0) a 7.0 ('a', 5, True, 7.0, 8) ('a', 5, 7.0, 8) ['a', 5, True, 7.0, 8] ###Markdown Ejercicio 7Concatena todos los elementos de la tupla en un unico string. Para ello utiliza el metodo `.join()` de los Strings> ```ejer_7 = ("cien", "cañones", "por", "banda")```Resultado: `cien cañones por banda` ###Code ejer_7 = ("cien", "cañones", "por", "banda") print(" ".join(ejer_7)) ###Output cien cañones por banda ###Markdown Ejercicio 8Obten el tercer elemento de la siguiente tupla, y el tercero empezando por la cola> ```ejer_8 = (3, 20, 3, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3)``` ###Code ejer_8 = (3, 20, 3, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3) print(ejer_8[2]) print(ejer_8[-3]) ###Output 3 90 ###Markdown Ejercicio 91. ¿Cuántas veces se repite el 3 en la siguiente tupla?2. Crea una tupla nueva con los elementos desde la posicion 5 a la 10.3. ¿Cuántos elementos tiene la tupla `ejer_9`?> ```ejer_9 = (3, 20, 3, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3, 5, 2, 4, 7, 9, 4, 2, 4, 3, 3, 4, 6, 7)``` ###Code ejer_9 = (3, 20, 3, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3, 5, 2, 4, 7, 9, 4, 2, 4, 3, 3, 4, 6, 7) print(ejer_9.count(3)) ejer_9_2 = ejer_9[4:10] print(ejer_9_2) print(len(ejer_9)) ###Output 7 (19, 3, 29, 45, 67, 78) 26 ###Markdown Ejercicio 10Comprueba si el numero 60 esta en la tupla del ejercicio 9 ###Code 60 in ejer_9 ###Output _____no_output_____ ###Markdown Ejercicio 111. Convierte la tupla del apartado 10 en una lista2. Convierte la tupla del apartado 10 en un set3. Convierte la tupla del apartado 10 en un diccionario. Usa también los indices ###Code ejer_11 = (3, 20, 3, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3, 5, 2, 4, 7, 9, 4, 2, 4, 3, 3, 4, 6, 7) # Convertir a lista print(list(ejer_11)) # Convertir en set print(set(ejer_11)) ejer_11_dict = {} # Convertir a diccionario for i,j in enumerate(ejer_11): #print(i) #print(j) ejer_11_dict[i] = j print(ejer_11_dict) ###Output [3, 20, 3, 47, 19, 3, 29, 45, 67, 78, 90, 3, 3, 5, 2, 4, 7, 9, 4, 2, 4, 3, 3, 4, 6, 7] {2, 3, 67, 5, 4, 7, 6, 9, 45, 78, 47, 19, 20, 90, 29} {0: 3, 1: 20, 2: 3, 3: 47, 4: 19, 5: 3, 6: 29, 7: 45, 8: 67, 9: 78, 10: 90, 11: 3, 12: 3, 13: 5, 14: 2, 15: 4, 16: 7, 17: 9, 18: 4, 19: 2, 20: 4, 21: 3, 22: 3, 23: 4, 24: 6, 25: 7} ###Markdown Ejercicio 12Convierte la siguiente tupla en un diccionario> ```ejer_12 = [("x", 1), ("x", 2), ("x", 3), ("y", 1), ("y", 2), ("z", 1)]``` ###Code ejer_12 = [("x", 1), ("x", 2), ("x", 3), ("y", 1), ("y", 2), ("z", 1)] ejer_12_dic = {} for i,j in ejer_12: #print(i) #print(j) ejer_12_dic[i] = j print(ejer_12_dic) dict(ejer_12) ejer_12_dic["x"] ###Output _____no_output_____ ###Markdown Ejercicio 131. Crea una lista ordenada ascendente con las claves del diccionario2. Crea otra lista ordenada descendente con los valores3. Añade una nueva clave/valor4. Busca la clave 2 dentro del diccionario5. Itera la clave y el valor del diccionario con un unico for> ```ejer_13 = {4:78, 2:98, 8:234, 5:29}``` ###Code ejer_13 = {4:78, 2:98, 8:234, 5:29} # Lista de claves ordenada ascendentemente list_1 = sorted(list(ejer_13.keys())) # Lista de valores ordenados descendentemente list_2 = sorted(list(ejer_13.values()), reverse = True) print(list_1) print(list_2) # Añadir elemento ejer_13[9] = 65 print(ejer_13) print(2 in ejer_13) for clave, valor in ejer_13.items(): print(f"Clave: {clave}, Valor -> {valor}") ###Output [2, 4, 5, 8] [234, 98, 78, 29] {4: 78, 2: 98, 8: 234, 5: 29, 9: 65} True Clave: 4, Valor -> 78 Clave: 2, Valor -> 98 Clave: 8, Valor -> 234 Clave: 5, Valor -> 29 Clave: 9, Valor -> 65 ###Markdown Ejercicio 14Junta ambos diccionarios. Para ello, utiliza `update> ```ejer_14_1 = {1: 11, 2: 22}```>> ```ejer_14_2 = {3: 33, 4: 44}``` ###Code ejer_14_1 = {1: 11, 2: 22} ejer_14_2 = {3: 33, 4: 44} ejer_14_1.update(ejer_14_2) print(ejer_14_1) ###Output {1: 11, 2: 22, 3: 33, 4: 44} ###Markdown Ejercicio 15Suma todos los valores del dicionario> ```ejer_15 = {1: 11, 2: 22, 3: 33, 4: 44, 5: 55}``` ###Code ejer_15 = {1: 11, 2: 22, 3: 33, 4: 44, 5: 55} print(sum(ejer_15.values())) ###Output 165 ###Markdown Ejercicio 16Multiplica todos los valores del diccionario> ```ejer_16 = {1: 11, 2: 22, 3: 33, 4: 44, 5: 55}``` ###Code ejer_16 = {1: 11, 2: 22, 3: 33, 4: 44, 5: 55} prod = 1 for i in ejer_16.values(): prod = prod * i print(prod) ###Output 19326120 ###Markdown Ejercicio 171. Crea un set de tres elementos2. Añade un cuarto3. Elimina el utlimo elemento añadido4. Elimina el elemento 10, si está presenta. Usa `discard()` ###Code # Crear set ejer_17 = {5,8,2} print(ejer_17) # Añadir elemento ejer_17.add(6) print(ejer_17) # Elimina el ultimo elemento ejer_17.remove(6) # Eliminar el elemento 10 ejer_17.discard(10) ###Output {8, 2, 5} {8, 2, 5, 6}
docs/T674201_Graph_embeddings.ipynb
###Markdown Graph ML Embeddings Installations ###Code !pip install node2vec !pip install karateclub !pip install python-Levenshtein !pip install gensim==3.8.0 !pip install git+https://github.com/palash1992/GEM.git !pip install stellargraph[demos]==1.2.1 ###Output _____no_output_____ ###Markdown Imports ###Code import numpy as np import pandas as pd import matplotlib.pyplot as plt from pathlib import Path import networkx as nx from networkx.drawing.layout import bipartite_layout import networkx.algorithms.community as nx_comm import os from scipy.io import mmread from collections import Counter import random from node2vec import Node2Vec from karateclub import Graph2Vec from node2vec.edges import HadamardEmbedder import os import numpy as np import pandas as pd import networkx as nx import stellargraph as sg from stellargraph.mapper import FullBatchNodeGenerator from stellargraph.layer import GCN import tensorflow as tf from tensorflow.keras import layers, optimizers, losses, metrics, Model from sklearn import preprocessing, model_selection from IPython.display import display, HTML from scipy.linalg import sqrtm import matplotlib.pyplot as plt from sklearn.manifold import TSNE %matplotlib inline default_edge_color = 'gray' default_node_color = '#407cc9' enhanced_node_color = '#f5b042' enhanced_edge_color = '#cc2f04' ###Output _____no_output_____ ###Markdown Plot utils Draw graph ###Code def draw_graph(G, pos_nodes=None, node_names={}, node_size=50, plot_weight=False): pos_nodes = pos_nodes if pos_nodes else nx.spring_layout(G) nx.draw(G, pos_nodes, with_labels=False, node_size=node_size, edge_color='gray', arrowsize=30) pos_attrs = {} for node, coords in pos_nodes.items(): pos_attrs[node] = (coords[0], coords[1] + 0.08) nx.draw_networkx_labels(G, pos_attrs, labels=node_names, font_family='serif', font_size=20) if plot_weight: pos_attrs = {} for node, coords in pos_nodes.items(): pos_attrs[node] = (coords[0], coords[1] + 0.08) nx.draw_networkx_labels(G, pos_attrs, font_family='serif', font_size=20) edge_labels=dict([((a,b,),d["weight"]) for a,b,d in G.edges(data=True)]) nx.draw_networkx_edge_labels(G, pos_nodes, edge_labels=edge_labels) plt.axis('off') axis = plt.gca() axis.set_xlim([1.2*x for x in axis.get_xlim()]) axis.set_ylim([1.2*y for y in axis.get_ylim()]) ###Output _____no_output_____ ###Markdown Draw enhanced path on the graph ###Code def draw_enhanced_path(G, path_to_enhance, node_names={}, filename=None, layout=None): path_edges = list(zip(path,path[1:])) pos_nodes = nx.spring_layout(G) if layout is None else layout(G) pos_nodes = nx.spring_layout(G) nx.draw(G, pos_nodes, with_labels=False, node_size=50, edge_color='gray') pos_attrs = {} for node, coords in pos_nodes.items(): pos_attrs[node] = (coords[0], coords[1] + 0.08) nx.draw_networkx_labels(G, pos_attrs, labels=node_names, font_family='serif') nx.draw_networkx_edges(G,pos_nodes,edgelist=path_edges, edge_color='#cc2f04', style='dashed', width=2.0) plt.axis('off') axis = plt.gca() axis.set_xlim([1.2*x for x in axis.get_xlim()]) axis.set_ylim([1.2*y for y in axis.get_ylim()]) if filename: plt.savefig(filename, format="png") ###Output _____no_output_____ ###Markdown Embedding module ###Code class Embeddings: """ Notes ----- Shallow embedding methods These methods are able to learn and return only the embedding values for the learned input data. Generally speaking, all the unsupervised embedding algorithms based on matrix factorization use the same principle. They all factorize an input graph expressed as a matrix in different components (commonly knows as matrix factorization). The main difference between each method lies in the loss function used during the optimization process. Indeed, different loss functions allow creating an embedding space that emphasizes specific properties of the input graph. """ @staticmethod def generate_random_graphs(n_graphs=20, nx_class=None): def generate_random(): n = random.randint(6, 20) k = random.randint(5, n) p = random.uniform(0, 1) if nx_class: return nx_class(n,k,p), [n,k,p] else: return nx.watts_strogatz_graph(n,k,p), [n,k,p] return [generate_random() for x in range(n_graphs)] def graph_embedding(self, graph_list=None, dim=2, wl_iterations=10): """ Given a dataset with m different graphs, the task is to build a machine learning algorithm capable of classifying a graph into the right class. We can then see this problem as a classification problem, where the dataset is defined by a list of pairs, <Gi,yi> , where Gi is a graph and yi is the class the graph belongs to. Representation learning (network embedding) is the task that aims to learn a mapping function f:G→Rn , from a discrete graph to a continuous domain. Function f will be capable of performing a low-dimensional vector representation such that the properties (local and global) of graph G are preserved. """ if graph_list is None: graph_list = self.generate_random_graphs() model = Graph2Vec(dimensions=dim, wl_iterations=wl_iterations) model.fit([x[0] for x in graph_list]) graph_embeddings = model.get_embedding() return graph_list, model, graph_embeddings def node_embedding(self, G=None, dim=2, window=10): """ Given a (possibly large) graph G=(V,E), the goal is to classify each vertex v∈V into the right class. In this setting, the dataset includes G and a list of pairs, <vi,yi>, where vi is a node of graph G and yi is the class to which the node belongs. In this case, the mapping function would be f:V→Rn. The Node2Vec algorithm can be seen as an extension of DeepWalk. Indeed, as with DeepWalk, Node2Vec also generates a set of random walks used as input to a skip-gram model. Once trained, the hidden layers of the skip-gram model are used to generate the embedding of the node in the graph. The main difference between the two algorithms lies in the way the random walks are generated. Indeed, if DeepWalk generates random walks without using any bias, in Node2Vec a new technique to generate biased random walks on the graph is introduced. The algorithm to generate the random walks combines graph exploration by merging Breadth-First Search (BFS) and Depth-First Search (DFS). The way those two algorithms are combined in the random walk's generation is regularized by two parameters p, and q. p defines the probability of a random walk getting back to the previous node, while q defines the probability that a random walk can pass through a previously unseen part of the graph. Due to this combination, Node2Vec can preserve high-order proximities by preserving local structures in the graph as well as global community structures. This new method of random walk generation allows solving the limitation of DeepWalk preserving the local neighborhood properties of the node. """ if G is None: G = nx.barbell_graph(m1=7, m2=4) node2vec = Node2Vec(G, dimensions=dim) model = node2vec.fit(window=window) node_embeddings = [model.wv.get_vector(str(x)) for x in G.nodes()] return G, model, node_embeddings def edge_embedding(self, G=None, dim=2, window=10): """ Given a (possibly large) graph G=(V,E), the goal is to classify each edge e∈E , into the right class. In this setting, the dataset includes G and a list of pairs, <ei,yi>, where ei is an edge of graph G and yi is the class to which the edge belongs. Another typical task for this level of granularity is link prediction, the problem of predicting the existence of a link between two existing nodes in a graph. In this case, the mapping function would be f:E→Rn. Contrary to the other embedding function, the Edge to Vector (Edge2Vec) algorithm generates the embedding space on edges, instead of nodes. This algorithm is a simple side effect of the embedding generated by using Node2Vec. The main idea is to use the node embedding of two adjacent nodes to perform some basic mathematical operations in order to extract the embedding of the edge connecting them. """ G, model, _ = self.node_embedding(G=G, dim=dim, window=window) edges_embs = HadamardEmbedder(keyed_vectors=model.wv) edge_embeddings = [edges_embs[(str(x[0]), str(x[1]))] for x in G.edges()] return G, model, edge_embeddings def graph_factorization(self, G=None, data_set=None, max_iter=10000, eta=1*10**-4, regu=1.0): """ The GF algorithm was one of the first models to reach good computational performance in order to perform the node embedding of a given graph. The loss function used in this method was mainly designed to improve GF performances and scalability. Indeed, the solution generated by this method could be noisy. Moreover, it should be noted, by looking at its matrix factorization formulation, that GF performs a strong symmetric factorization. This property is particularly suitable for undirected graphs, where the adjacency matrix is symmetric, but could be a potential limitation for undirected graphs. """ if G is None: G = nx.barbell_graph(m1=7, m2=4) from gem.embedding.gf import GraphFactorization Path("gem/intermediate").mkdir(parents=True, exist_ok=True) model = GraphFactorization(d=2, data_set=data_set, max_iter=max_iter, eta=eta, regu=regu) model.learn_embedding(G) return G, model def graph_representation(self, G=None, dimensions=2, order=3): """ Graph representation with global structure information (GraphRep), such as HOPE, allows us to preserve higher-order proximity without forcing its embeddings to have symmetric properties. We initialize the GraRep class from the karateclub library. In this implementation, the dimension parameter represents the dimension of the embedding space, while the order parameter defines the maximum number of orders of proximity between nodes. The number of columns of the final embedding matrix (stored, in the example, in the embeddings variable) is dimension x order, since, as we said, for each proximity order an embedding is computed and concatenated in the final embedding matrix. """ if G is None: G = nx.barbell_graph(m1=7, m2=4) from karateclub.node_embedding.neighbourhood.grarep import GraRep model = GraRep(dimensions=dimensions, order=order) model.fit(G) embeddings = model.get_embedding() return G, model, embeddings def hope(self, G=None, d=4, beta=0.01): if G is None: G = nx.barbell_graph(m1=7, m2=4) from gem.embedding.hope import HOPE model = HOPE(d=d, beta=beta) model.learn_embedding(G) return G, model def gcn_embedding(self, G=None): """ Unsupervised graph representation learning using Graph ConvNet as encoder The model embeds a graph by using stacked Graph ConvNet layers """ if G is None: G = nx.barbell_graph(m1=7, m2=4) order = np.arange(G.number_of_nodes()) A = nx.to_numpy_matrix(G, nodelist=order) I = np.eye(G.number_of_nodes()) A_hat = A + np.eye(G.number_of_nodes()) # add self-connections D_hat = np.array(np.sum(A_hat, axis=0))[0] D_hat = np.array(np.diag(D_hat)) D_hat = np.linalg.inv(sqrtm(D_hat)) A_hat = D_hat @ A_hat @ D_hat gcn1 = GCNLayer(G.number_of_nodes(), 8) gcn2 = GCNLayer(8, 4) gcn3 = GCNLayer(4, 2) H1 = gcn1.forward(A_hat, I) H2 = gcn2.forward(A_hat, H1) H3 = gcn3.forward(A_hat, H2) embeddings = H3 return G, embeddings class GCNLayer(): def __init__(self, n_inputs, n_outputs): self.n_inputs = n_inputs self.n_outputs = n_outputs self.W = self._glorot_init(self.n_outputs, self.n_inputs) self.activation = np.tanh @staticmethod def _glorot_init(nin, nout): sd = np.sqrt(6.0 / (nin + nout)) return np.random.uniform(-sd, sd, size=(nin, nout)) def forward(self, A, X): self._X = (A @ X).T # (N,N)*(N,n_outputs) ==> (n_outputs,N) H = self.W @ self._X # (N, D)*(D, n_outputs) => (N, n_outputs) H = self.activation(H) return H.T # (n_outputs, N) ###Output _____no_output_____ ###Markdown Runs ###Code ############################################################################### # Drawing Undirected Graphs ############################################################################### G = nx.Graph() V = {'Dublin', 'Paris', 'Milan', 'Rome'} E = [('Milan','Dublin'), ('Milan','Paris'), ('Paris','Dublin'), ('Milan','Rome')] G.add_nodes_from(V) G.add_edges_from(E) draw_graph(G, pos_nodes=nx.shell_layout(G), node_size=500) new_nodes = {'London', 'Madrid'} new_edges = [('London','Rome'), ('Madrid','Paris')] G.add_nodes_from(new_nodes) G.add_edges_from(new_edges) draw_graph(G, pos_nodes=nx.shell_layout(G), node_size=500) node_remove = {'London', 'Rome'} G.remove_nodes_from(node_remove) draw_graph(G, pos_nodes=nx.shell_layout(G), node_size=500) node_edges = [('Milan','Dublin'), ('Milan','Paris')] G.remove_edges_from(node_edges) draw_graph(G, pos_nodes=nx.shell_layout(G), node_size=500) G = nx.Graph() nodes = {1:'Dublin',2:'Paris',3:'Milan',4:'Rome',5:'Naples',6:'Moscow',7:'Tokyo'} G.add_nodes_from(nodes.keys()) G.add_edges_from([(1,2),(1,3),(2,3),(3,4),(4,5),(5,6),(6,7),(7,5)]) draw_graph(G, node_names=nodes, pos_nodes=nx.spring_layout(G), node_size=50) ############################################################################### # Drawing Directed Graphs ############################################################################### G = nx.DiGraph() V = {'Dublin', 'Paris', 'Milan', 'Rome'} E = [('Milan','Dublin'), ('Paris','Milan'), ('Paris','Dublin'), ('Milan','Rome')] G.add_nodes_from(V) G.add_edges_from(E) draw_graph(G, pos_nodes=nx.shell_layout(G), node_size=500) ############################################################################### # Drawing Weighted Directed Graphs ############################################################################### G = nx.MultiDiGraph() V = {'Paris', 'Dublin','Milan', 'Rome'} E = [ ('Paris','Dublin', 11), ('Paris','Milan', 8), ('Milan','Rome', 5),('Milan','Dublin', 19)] G.add_nodes_from(V) G.add_weighted_edges_from(E) draw_graph(G, pos_nodes=nx.shell_layout(G), node_size=500, plot_weight=True) ############################################################################### # Drawing Shortest Path ############################################################################### G = nx.Graph() nodes = {1:'Dublin',2:'Paris',3:'Milan',4:'Rome',5:'Naples',6:'Moscow',7:'Tokyo'} G.add_nodes_from(nodes.keys()) G.add_edges_from([(1,2),(1,3),(2,3),(3,4),(4,5),(5,6),(6,7),(7,5)]) path = nx.shortest_path(G, source=1, target=7) draw_enhanced_path(G, path, node_names=nodes) ############################################################################### # Network Efficieny Graphs ############################################################################### G = nx.complete_graph(n=7) nodes = {0:'Dublin',1:'Paris',2:'Milan',3:'Rome',4:'Naples',5:'Moscow',6:'Tokyo'} ge = round(nx.global_efficiency(G),2) ax = plt.gca() ax.text(-.4, -1.3, "Global Efficiency:{}".format(ge), fontsize=14, ha='left', va='bottom'); draw_graph(G, node_names=nodes, pos_nodes=nx.spring_layout(G)) G = nx.cycle_graph(n=7) nodes = {0:'Dublin',1:'Paris',2:'Milan',3:'Rome',4:'Naples',5:'Moscow',6:'Tokyo'} le = round(nx.global_efficiency(G),2) ax = plt.gca() ax.text(-.4, -1.3, "Global Efficiency:{}".format(le), fontsize=14, ha='left', va='bottom'); draw_graph(G, node_names=nodes, pos_nodes=nx.spring_layout(G)) ############################################################################### # Clustering Coefficient ############################################################################### G = nx.Graph() nodes = {1:'Dublin',2:'Paris',3:'Milan',4:'Rome',5:'Naples',6:'Moscow',7:'Tokyo'} G.add_nodes_from(nodes.keys()) G.add_edges_from([(1,2),(1,3),(2,3),(3,4),(4,5),(5,6),(6,7),(7,5)]) cc = nx.clustering(G) node_size=[(v + 0.1) * 200 for v in cc.values()] draw_graph(G, node_names=nodes, node_size=node_size, pos_nodes=nx.spring_layout(G)) ############################################################################### # Drawing Benchmark Graphs ############################################################################### complete = nx.complete_graph(n=7) lollipop = nx.lollipop_graph(m=7, n=3) barbell = nx.barbell_graph(m1=7, m2=4) plt.figure(figsize=(15,6)) plt.subplot(1,3,1) draw_graph(complete) plt.title("Complete") plt.subplot(1,3,2) plt.title("Lollipop") draw_graph(lollipop) plt.subplot(1,3,3) plt.title("Barbell") draw_graph(barbell) ############################################################################### # Graph2vec embedding ############################################################################### embedder = Embeddings() _, _, graph_embeddings = embedder.graph_embedding() fig, ax = plt.subplots(figsize=(10,10)) for i, vec in enumerate(graph_embeddings): ax.scatter(vec[0],vec[1], s=1000) ax.annotate(str(i), (vec[0],vec[1]), fontsize=40) ############################################################################### # Node2vec embedding ############################################################################### embedder = Embeddings() G, model, node_embeddings = embedder.node_embedding() fig, ax = plt.subplots(figsize=(10,10)) for x in G.nodes(): v = model.wv.get_vector(str(x)) ax.scatter(v[0],v[1], s=1000) ax.annotate(str(x), (v[0],v[1]), fontsize=12) ############################################################################### # Edge2vec embedding ############################################################################### embedder = Embeddings() G, model, edge_embeddings = embedder.edge_embedding() fig, ax = plt.subplots(figsize=(10,10)) for x,v in zip(G.edges(),edge_embeddings): ax.scatter(v[0],v[1], s=1000) ax.annotate(str(x), (v[0],v[1]), fontsize=16) ############################################################################### # Graph Factorization embedding ############################################################################### embedder = Embeddings() G, model = embedder.graph_factorization() fig, ax = plt.subplots(figsize=(10,10)) for x in G.nodes(): v = model.get_embedding()[x] ax.scatter(v[0],v[1], s=1000) ax.annotate(str(x), (v[0],v[1]), fontsize=12) ############################################################################### # Graph Representation embedding ############################################################################### embedder = Embeddings() G, model, embeddings = embedder.graph_representation() fig, ax = plt.subplots(1, 3, figsize=(16,5)) for x in G.nodes(): v = model.get_embedding()[x] ax[0].scatter(v[0],v[1], s=1000) ax[0].annotate(str(x), (v[0],v[1]), fontsize=12) ax[0].set_title('k=1') ax[1].scatter(v[2],v[3], s=1000) ax[1].annotate(str(x), (v[2],v[3]), fontsize=12) ax[1].set_title('k=2') ax[2].scatter(v[4],v[5], s=1000) ax[2].annotate(str(x), (v[4],v[5]), fontsize=12) ax[2].set_title('k=3') ############################################################################### # HOPE embedding ############################################################################### embedder = Embeddings() G, model = embedder.hope() fig, ax = plt.subplots(figsize=(10,10)) for x in G.nodes(): v = model.get_embedding()[x,2:] ax.scatter(v[0],v[1], s=1000) ax.annotate(str(x), (v[0],v[1]), fontsize=20) ###Output _____no_output_____
tools/data-analysis/causal-occlusion/cfv_main_figures.ipynb
###Markdown This notebook creates the plots for the main paper. Imports ###Code # to import from mturk folder import os, sys, inspect currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) mturkdir = os.path.join(os.path.dirname(os.path.dirname(currentdir)), "mturk") sys.path.insert(0, mturkdir) from mturk import RepeatedTaskResult import numpy as np from matplotlib import pyplot as plt import pickle from glob import glob import pandas as pd import seaborn as sns import json import utils_figures as utf import utils_figures_helper as utf_helper import utils_MTurk_figures as utf_mturk import utils_data as utd ###Output _____no_output_____ ###Markdown Parameters ###Code # path to the folder containing the pkl files generated by the experiment's code raw_results_folder = "data/counterfactual_experiment" save_csv = True include_baselines = True ignore_duplicate_participants = False # set to False when using data that has no duplicates. # START for figures save_fig = False # name of the folder in ./figures/ where all resulting figures will be saved exp_str = "counterfactual_experiment" instr_type_list = ["optimized", "natural", "mixed", "blur", "none"] branches_labels_list = ["3x3", "pool"] kernel_size_list = ["1", "3"] # END for figures # START for payment mturk_payment_one_HIT = 2.34 mturk_payment_one_HIT_none = 0.84 repetition_factor_due_to_exclusion = 1.35 expected_distinct_workers = 50 # END for payment instruction_labels = { "optimized": "Synthetic", "natural": "Natural", "mixed": "Mixed", "none": "None", "blur": "Blur", } labels = [instruction_labels[it] for it in instr_type_list] if save_fig: os.makedirs(os.path.join("figures", exp_str), exist_ok=True) ###Output _____no_output_____ ###Markdown Load data & preprocess ###Code """ Check if the `calculate_relative_activation_difference.py` script was already run for all json configurations If not, do so. to add the query activation information to the structure save the resulting files with the filenames shown below """ if include_baselines: structure_json_map = { "natural": "natural_with_baselines.json", "optimized": "optimized_with_baselines.json", "mixed": "mixed_with_baselines.json", "blur": "natural_blur_with_baselines.json", "none": "natural_with_baselines.json", } else: structure_json_map = { "natural": "natural.json", "optimized": "optimized.json", "mixed": "mixed.json", "blur": "natural_blur.json", "none": "natural.json", } trial_structures = utd.load_and_parse_trial_structure( raw_results_folder, [structure_json_map[it] for it in instr_type_list] ) trial_structures = {k: v for k, v in zip(instr_type_list, trial_structures)} df, df_checks, df_feedback = utd.load_and_parse_all_results( raw_results_folder, instr_type_list ) ###Output _____no_output_____ ###Markdown Add a column to the result df indicating whether the row belongs to an excluded or included response ###Code def get_map_excluded_responses(column_name="passed_checks"): def map_excluded_responses(row): rows = df_checks[ (df_checks["task_id"] == row["task_id"]) & (df_checks["response_index"] == row["response_index"]) ] result = not rows[column_name].item() return result return map_excluded_responses df["excluded_response"] = df.apply(get_map_excluded_responses("passed_checks"), axis=1) ###Output _____no_output_____ ###Markdown Create a unique column based on task id and response id (unique within each task) ###Code df, df_checks = utd.add_task_response_id(df, df_checks) df_main = ( df[(df["catch_trial"] == False) & (df["is_demo"] == False)] .reset_index() .drop("index", axis=1) ) df_catch_trials = ( df[(df["catch_trial"] == True) & (df["is_demo"] == False)] .reset_index() .drop("index", axis=1) ) df_demo_trials = df[df["is_demo"] == True].reset_index().drop("index", axis=1) ###Output _____no_output_____ ###Markdown Append structure information such as layer, kernel size, etc. to the dataframe ###Code df_main = utd.append_trial_structure_to_results(df_main, trial_structures) df_catch_trials = utd.append_trial_structure_to_results( df_catch_trials, trial_structures ) if ignore_duplicate_participants: df_duplicate_tasks = pd.read_csv( os.path.join(raw_results_folder, "duplicate_tasks.csv") ) df_main["excluded_response"] = df_main.apply( axis=1, func=lambda row: True if row["excluded_response"] else ( len( df_duplicate_tasks[ (df_duplicate_tasks["mode"] == row["mode"]) & (df_duplicate_tasks["task_number"] == row["task_number"]) ] ) > 0 ), ) ###Output _____no_output_____ ###Markdown Split data up in trials belonging to excluded responses, and those that passed the exclusion criteria ###Code df_main_excluded = df_main[df_main["excluded_response"]] df_main_not_excluded = df_main[~df_main["excluded_response"]] df_catch_trials_excluded = df_catch_trials[df_catch_trials["excluded_response"]] df_catch_trials_not_excluded = df_catch_trials[~df_catch_trials["excluded_response"]] df_demo_trials_excluded = df_demo_trials[df_demo_trials["excluded_response"]] df_demo_trials_not_excluded = df_demo_trials[~df_demo_trials["excluded_response"]] ###Output _____no_output_____ ###Markdown Calculate how often the demo trials had to be repeated ###Code df_checks = utd.checks_add_demo_trial_repetitions(df_demo_trials, df_checks) df, df_checks = utd.process_checks(df, df_checks) df_catch_trials_not_excluded_ignoring_catch_trials = utd.get_catch_trials_as_main_data( df_catch_trials, df_checks ) df_checks_not_excluded = df_checks[df_checks["passed_checks"]] df_checks_excluded = df_checks[~df_checks["passed_checks"]] if save_csv: # save dataframes to csv df_checks.to_csv(os.path.join(raw_results_folder, "df_exclusion_criteria.csv")) df.to_csv(os.path.join(raw_results_folder, "df_trials.csv")) figures_folder = os.path.join( "figures", os.path.basename(os.path.realpath(raw_results_folder)) ) if save_fig: os.makedirs(figures_folder, exist_ok=True) print("Saving results to", figures_folder) ###Output _____no_output_____ ###Markdown Figure 1C ###Code df_expert_baseline = pd.read_csv("data/baselines/df_main_trials.csv") df_expert_baseline["expert_baseline"] = True df_main_not_excluded_copy = df_main_not_excluded.copy() df_main_not_excluded_copy["expert_baseline"] = False df_main_not_excluded_with_expert_baseline = pd.concat((df_expert_baseline, df_main_not_excluded_copy)).reset_index(drop=True) utf.make_plot_workers_understood_task( df_main_not_excluded_with_expert_baseline, figures_folder, exp_str, ["optimized", "natural", "none"], ["Synthetic", "Natural", "None"], fig_1=True, include_experts=False, save_fig=save_fig ) ###Output _____no_output_____ ###Markdown Figure 3A: Performance ###Code utf.make_plot_workers_understood_task( df_main_not_excluded_with_expert_baseline, figures_folder, exp_str, instr_type_list, labels, fig_1=False, save_fig=save_fig ) del df_main_not_excluded_with_expert_baseline, df_main_not_excluded_copy ###Output _____no_output_____ ###Markdown Figure 3B: Reaction Time ###Code utf.make_plot_natural_are_better_wrt_reaction_time( df_main_not_excluded, results_folder=figures_folder, save_fig=save_fig, instr_type_list=instr_type_list, labels=labels ) ###Output _____no_output_____ ###Markdown Figure 4A: Baseline Accuracies ###Code # Load expert data df_expert_baseline = pd.read_csv("data/baselines/df_main_trials.csv") df_expert_baseline["expert_baseline"] = True df_expert_baseline["mode_extended"] = df_expert_baseline.apply( lambda row: "e_" + row["mode"], axis=1 # e for expert ) df_expert_baseline["kernel_size"] = df_expert_baseline.apply( lambda row: str(row["kernel_size"]), axis=1 ) df_expert_baseline["layer"] = df_expert_baseline.apply( lambda row: str(row["layer"]), axis=1 ) # extend worker df with new columns df_main_not_excluded_copy = df_main_not_excluded.copy() df_main_not_excluded_copy["expert_baseline"] = False df_main_not_excluded_copy["mode_extended"] = df_main_not_excluded_copy.apply( lambda row: "w_" + row["mode"], axis=1 # w for worker ) df_main_not_excluded_with_expert_baseline = pd.concat( (df_expert_baseline, df_main_not_excluded_copy) ).reset_index(drop=True) # load primary object baseline if os.path.exists("data/baselines/df_primary_object_baseline.csv"): df_primary_object_baseline = pd.read_csv( "data/baselines2/df_primary_object_baseline.csv" ) def parse_primary_object_baseline(row): mask = ( (df_primary_object_baseline["batch"] == row["batch"]) & (df_primary_object_baseline["layer"] == row["layer"]) & (df_primary_object_baseline["kernel_size"] == row["kernel_size"]) ) selected_rows = df_primary_object_baseline[mask] if not len(selected_rows) == 1: print( "missing information for row:", row[["batch", "trial_index", "mode", "task_number"]], ) print() return selected_rows.iloc[0]["primary_object_choice"] df_main_not_excluded_with_expert_baseline[ "primary_object_baseline_choice" ] = df_main_not_excluded_with_expert_baseline.apply( axis=1, func=parse_primary_object_baseline ) # clean up del df_primary_object_baseline else: print( "Could not find objects baselines csv and, thus, cannot append this information to the dataframe" ) df_main_not_excluded_with_expert_baseline[ "correct_center" ] = df_main_not_excluded_with_expert_baseline.apply( lambda row: row["max_query_center_distance"] > row["min_query_center_distance"], axis=1, ) df_main_not_excluded_with_expert_baseline[ "correct_std" ] = df_main_not_excluded_with_expert_baseline.apply( lambda row: row["max_query_patch_std"] < row["min_query_patch_std"], axis=1 ) df_main_not_excluded_with_expert_baseline[ "correct_primary" ] = df_main_not_excluded_with_expert_baseline.apply( lambda row: True if row["primary_object_baseline_choice"] == 1 else False, axis=1 ) df_main_not_excluded_with_expert_baseline[ "correct_saliency" ] = df_main_not_excluded_with_expert_baseline.apply( lambda row: row["max_query_patch_saliency"] < row["min_query_patch_saliency"], axis=1, ) baseline_accuracies = { "Center": df_main_not_excluded_with_expert_baseline[ ~df_main_not_excluded_with_expert_baseline["expert_baseline"] # only taking dataframe from workers ]["correct_center"].mean(), "Variance": df_main_not_excluded_with_expert_baseline[ ~df_main_not_excluded_with_expert_baseline["expert_baseline"] ]["correct_std"].mean(), "Object": 0.6344107407407408, "Saliency": df_main_not_excluded_with_expert_baseline[ ~df_main_not_excluded_with_expert_baseline["expert_baseline"] ]["correct_saliency"].mean(), } baseline_sems = { "Object": 0.006435863163504224, } utf.plot_baseline_accuracy( baseline_accuracies, sems=baseline_sems, results_folder=figures_folder, save_fig=save_fig, label_order=["Center", "Object", "Variance", "Saliency"], ) ###Output _____no_output_____ ###Markdown Figure 4 B and C: Cohen's Kappa ###Code extended_mode_list = [ "w_optimized", "w_natural", "w_mixed", "w_blur", "w_none", "b_center", "b_std", "b_saliency", ] cohens_kappa = utf_helper.get_cohens_kappa_all_conditions_with_each_other( df_main_not_excluded_with_expert_baseline, extended_mode_list, "mode_extended" ) ( cohens_kappa_matrix, cohens_kappa_std_matrix, cohens_kappa_sem_matrix, ) = utf_helper.get_cohens_kappa_matrix_all_conditions_with_each_other( extended_mode_list, cohens_kappa ) extended_mode_label_list = [ "Synthetic", "Natural", "Mixed", "Blur", "None", "Center\nBaseline", "Variance\nBaseline", "Saliency\nBaseline", ] extended_mode_list = [ "w_optimized", "w_natural", "w_mixed", "w_blur", "w_none", "b_center", "b_std", "b_saliency", ] utf_mturk.plot_worker_baseline_consistency_matrix( np.round(cohens_kappa_matrix * 100, 2).astype(int), np.round(2 * cohens_kappa_sem_matrix * 100, 2).astype(int), extended_mode_list, extended_mode_label_list, figures_folder, save_fig=save_fig, vmin=cohens_kappa_matrix.min() * 100, vmax=cohens_kappa_matrix.max() * 100, ) extended_mode_list = ["w_optimized", "w_natural", "b_saliency"] ( cohens_kappa_submatrix, cohens_kappa_std_submatrix, cohens_kappa_sem_submatrix, ) = utf_helper.get_cohens_kappa_matrix_all_conditions_with_each_other( extended_mode_list, cohens_kappa ) extended_mode_label_list = ["Synthetic", "Natural", "Saliency\nBaseline"] utf_mturk.plot_worker_baseline_consistency_matrix( np.round(cohens_kappa_submatrix * 100, 2).astype(int), np.round(2 * cohens_kappa_sem_submatrix * 100, 2).astype(int), extended_mode_list, extended_mode_label_list, figures_folder, save_fig=save_fig, vmin=cohens_kappa_matrix.min() * 100, vmax=cohens_kappa_matrix.max() * 100, ) ###Output _____no_output_____ ###Markdown Figure 5A, B: Performance by Unit ###Code for kernel_size_i in df_main_not_excluded["kernel_size"].unique(): print(f"kernel_size {kernel_size_i}") utf_mturk.plot_accuracy_per_layer( df_main_not_excluded[df_main_not_excluded["kernel_size"] == kernel_size_i], results_folder=figures_folder, save_fig=save_fig, instr_type_list=instr_type_list, title_prefix=f"For kernel size {kernel_size_i}: ", legend=False, ) # include error bars by setting show_sem=True ###Output _____no_output_____ ###Markdown Figure 5C Stop using the catch trials as exclusion criterion and plot the, thus, unbiased performance over these trials ###Code utf_mturk.plot_accuracy_per_layer( df_catch_trials_not_excluded_ignoring_catch_trials, results_folder=figures_folder, save_fig=save_fig, instr_type_list=instr_type_list, legend=False, ) ###Output _____no_output_____ ###Markdown Figure 7: Relative Activation Difference ###Code for kernel_size_i in sorted(df_main_not_excluded["kernel_size"].unique()): utf_mturk.plot_accuracy_vs_relative_activation_difference( df_main_not_excluded[df_main_not_excluded["kernel_size"] == kernel_size_i], results_folder=figures_folder, save_fig=save_fig, fig_name_suffix=f"_kernel_size{kernel_size_i}", ) ###Output _____no_output_____
chapter2/homework/computer/3-29/201611680275.ipynb
###Markdown 练习1: ###Code def compute_sum(end): i = 0 total_n = 1 while i < end: i = i + 1 total_n = total_n * i return total_n n = int(input('请输入第1个整数,以回车结束。')) m = int(input('请输入第2个整数,以回车结束。')) k = int(input('请输入第3个整数,以回车结束。')) print('最终的和是:', compute_sum(m) + compute_sum(n) + compute_sum(k)) ###Output 请输入第1个整数,以回车结束。3 请输入第2个整数,以回车结束。2 请输入第3个整数,以回车结束。2 最终的和是: 10 ###Markdown 练习2: ###Code def compute(end): pro = 1 num = 1 i = 1.0 j = 1.0/i total_m = 0 while num <= end: j = 1.0/i * pro total_m = total_m + j pro = pro * (-1) i = i + 2 num = num + 1 return total_m n1 = int(input('请输入一个整数,以回车结束:')) print('最终和的四倍是:',compute(n1) * 4.0) n2 = int(input('请输入一个整数,以回车结束:')) print('最终和的四倍是:',compute(n2) * 4.0) ###Output 请输入一个整数,以回车结束:1000 最终和的四倍是: 3.140592653839794 请输入一个整数,以回车结束:100000 最终和的四倍是: 3.1415826535897198 ###Markdown 练习3(第一小题): ###Code name=input('请输入你的名字:') def your_sex(s): if s==1: sex='Miss' else: sex='Mr' return sex def birthday(birthday_month,birthday_data): if birthday_month==1: if birthday_data>=20: xinzuo='水瓶' else: xinzuo='摩羯' elif birthday_month==2: if birthday_data>=19: xinzuo='双鱼' else: xinzuo='水瓶' elif birthday_month==3: if birthday_data>=21: xinzuo='白羊' else: xinzuo='双鱼' elif birthday_month==4: if birthday_data>=20: xinzuo='金牛' else: xinzuo='白羊' elif birthday_month==5: if birthday_data>=21: xinzuo='双子' else: xinzuo='金牛' elif birthday_month==6: if birthday_data>=22: xinzuo='巨蟹' else: xinzuo='双子' elif birthday_month==7: if birthday_data>=23: xinzuo='狮子' else: xinzuo='巨蟹' elif birthday_month==8: if birthday_data>=23: xinzuo='处女' else: xinzuo='狮子' elif birthday_month==9: if birthday_data>=23: xinzuo='天秤' else: xinzuo='处女' elif birthday_month==10: if birthday_data>=24: xinzuo='天蝎' else: xinzuo='天秤' elif birthday_month==11: if birthday_data>=23: xinzuo='射手' else: xinzuo='天蝎' elif birthday_month==12: if birthday_data>=22: xinzuo='摩羯' else: xinzuo='射手' return xinzuo ni=int(input('如果你是女性,输入1,如果你是男性,输入2:')) birthday_month=int(input('你的生日月份是:')) birthday_data=int(input('你的生日日期是:')) print('你好,',your_sex(ni),name,'你是',birthday(birthday_month,birthday_data)) ###Output 请输入你的名字:du 如果你是女性,输入1,如果你是男性,输入2:1 你的生日月份是:1 你的生日日期是:2 你好, Miss du 你是 摩羯 ###Markdown 练习3(第二小题): ###Code def add(word): if word.endswith('s') or word.endswith('x') or word.endswith('ch') or word.endswith('sh') or word.endswith('o'): end='加es' elif word.endswith('ay')==0 and word.endswith('ey')==0 and word.endswith('iy')==0 and word.endswith('oy')==0 and word.endswith('uy')==0 and word.endswith('yy')==0 and word.endswith('y'): end='变y为i再加es' elif word=='have': end='变为has' else: end='直接加s' return end verb=input('请输入一个动词的原型:') print('它的变化规则是:',add(verb)) ###Output 请输入一个动词的原型:study 它的变化规则是: 变y为i再加es ###Markdown 挑战性练习: ###Code def compute_sum(star,end,tap): i = star total_n = 0 while i <= end: total_n = total_n + i i = i + tap return total_n m = int(input('请输入开始整数,以回车结束。')) n = int(input('请输入结束整数,以回车结束。')) k = int(input('请输入间隔整数,以回车结束。')) print('最终的和是:', compute_sum(m,n,k)) ###Output 请输入开始整数,以回车结束。1 请输入结束整数,以回车结束。100 请输入间隔整数,以回车结束。2 最终的和是: 2500
notebooks/Power_Split_001.ipynb
###Markdown Get recording ###Code from IPython.core.display import display, HTML display(HTML("<style>.container { width:100% !important; }</style>")) %load_ext autoreload %autoreload 2 from Cfg import Cfg from RecordingCorpus import RecordingCorpus from multiprocessing import Pool import warnings warnings.filterwarnings("ignore") import librosa import librosa.display import numpy as np %matplotlib inline import matplotlib.pyplot as plt C = Cfg('NIST', 16000, 'amharic', 'build') if __name__ == '__main__': with Pool(16) as pool: recordings = RecordingCorpus(C, pool) a=recordings.artifacts[0] transcript=[x[3:] for x in a.target.value if float(x[4]) <= 60] speech=[(int(float(x)*C.sample_rate), int(float(y)*C.sample_rate), z) for x,y,z in [w for w in transcript if len(w)==3]] silence=[(int(float(x)*C.sample_rate), int(float(y)*C.sample_rate)) for x,y in [w for w in transcript if len(w)==2]] audio=a.source.value[0:16*C.sample_rate] audio=a.source.value from collect_false import collect_false T=np.arange(audio.shape[0])/C.sample_rate S = librosa.feature.melspectrogram(y=audio, sr=C.sample_rate, n_mels=64, fmax=8000) S_dB = librosa.power_to_db(S, ref=np.max) s_dB_mean=np.mean(S_dB,axis=0) speech_q=(s_dB_mean>-70) TSQ=T[-1]*np.arange(len(speech_q))/len(speech_q) silences=T[-1]*collect_false(speech_q)/len(speech_q) int(pauses[-1][-1]*C.sample_rate), audio.shape[0] max_duration=16.5 for gap in np.linspace(2,0.01,20): pauses=[(x,y) for x,y in silences if y-x > gap and int(y*C.sample_rate) < audio.shape[0]] cuts=np.array([int(C.sample_rate*(x+y)/2) for x,y in pauses if x != 0.0]) sizes=np.diff(np.hstack([[0],cuts]))/C.sample_rate if sizes.max() <= max_duration: print("gap", gap) break plt.figure(figsize=(60,8)) ax1 = plt.subplot(1,1,1) ax1.plot(T, audio, color='blue'); for cut in cuts: ax1.axvline(x=cut/C.sample_rate, color='purple') plt.show() plt.figure(figsize=(60,8)) ax1 = plt.subplot(1,1,1) ax1.plot(T, audio, color='blue'); ax1.plot(TSQ, 2*speech_q-1, color='green') for (x,y) in pauses: ax1.plot([x,y], [0,0], color='red', linewidth=3) for cut in cuts: ax1.axvline(x=cut/C.sample_rate, color='purple') plt.xlim(350,380) plt.show() plt.figure(figsize=(60,8)) ax1 = plt.subplot(2,1,1) ax1.plot(T, audio, color='blue'); ax1.plot(TSQ, 2*speech_q-1, color='green') for (x,y) in silences: if y-x > 0.2: ax1.plot([x,y], [0,0], color='red', linewidth=3) ax2 = plt.subplot(2,1,2) librosa.display.specshow(S_dB, x_axis='time', y_axis='mel', sr=C.sample_rate, fmax=8000); ax2.sharex(ax1) plt.xlim(510,530) plt.show() silences ###Output _____no_output_____
third_party_apps/xbrl_extracts_4.ipynb
###Markdown <div style=" width: 100%; height: 100px; border:none; background:linear-gradient(-45deg, d84227, ce3587); text-align: center; position: relative;"> <span style=" font-size: 40px; padding: 0 10px; color: white; margin: 0; position: absolute; top: 50%; left: 50%; -ms-transform: translate(-50%, -50%); transform: translate(-50%, -50%); font-weight: bold; "> XBRL PARSER ###Code """ Martin Wood - Office for National Statistics [email protected] 23/07/2018 XBRL parser Contains functions that scrape and clean an XBRL document's content and variables, returning a dict ready for dumping into MongoDB. ELliott PHillips - Office for National Statistics [email protected] 30/06/2020 Code adapted and furthered for Companies House XBRL accounts parsing and outputting. """ import os import re import numpy as np import pandas as pd from datetime import datetime from dateutil import parser from bs4 import BeautifulSoup as BS # Can parse xml or html docs # Table of variables and values that indicate consolidated status consolidation_var_table = { "includedinconsolidationsubsidiary": True, "investmententityrequiredtoapplyexceptionfromconsolidationtruefalse": True, "subsidiaryunconsolidatedtruefalse": False, "descriptionreasonwhyentityhasnotpreparedconsolidatedfinancialstatements": "exist", "consolidationpolicy": "exist" } def clean_value(string): """ Take a value that's stored as a string, clean it and convert to numeric. If it's just a dash, it's taken to mean zero. """ if string.strip() == "-": return (0.0) try: return float(string.strip().replace(",", "").replace(" ", "")) except: pass return (string) def retrieve_from_context(soup, contextref): """ Used where an element of the document contained no data, only a reference to a context element. Finds the relevant context element and retrieves the relevant data. Returns a text string Keyword arguments: soup -- BeautifulSoup souped html/xml object contextref -- the id of the context element to be raided """ try: context = soup.find("xbrli:context", id=contextref) contents = context.find("xbrldi:explicitmember").get_text().split(":")[-1].strip() except: contents = "" return (contents) def retrieve_accounting_standard(soup): """ Gets the account reporting standard in use in a document by hunting down the link to the schema reference sheet that always appears to be in the document, and extracting the format and standard date from the string of the url itself. WARNING - That means that there's a lot of implicity hardcoded info on the way these links are formated and referenced, within this function. Might need changing someday. Returns a 3-tuple (standard, date, original url) Keyword arguments: soup -- BeautifulSoup souped html/xml object """ # Find the relevant link by its unique attribute link_obj = soup.find("link:schemaref") # If we didn't find anything it's an xml doc using a different # element name: if link_obj == None: link_obj = soup.find("schemaref") # extract the name of the .xsd schema file, which contains format # and date information text = link_obj['xlink:href'].split("/")[-1].split(".")[0] # Split the extracted text into format and date, return values return (text[:-10].strip("-"), text[-10:], link_obj['xlink:href']) def retrieve_unit(soup, each): """ Gets the reporting unit by trying to chase a unitref to its source, alternatively uses element attribute unitref if it's not a reference to another element. Returns the unit Keyword arguments: soup -- BeautifulSoup souped html/xml object each -- element of BeautifulSoup souped object """ # If not, try to discover the unit string in the # soup object try: unit_str = soup.find(id=each['unitref']).get_text() except: # Or if not, in the attributes of the element try: unit_str = each.attrs['unitref'] except: return ("NA") return (unit_str.strip()) def retrieve_date(soup, each): """ Gets the reporting date by trying to chase a contextref to its source and extract its period, alternatively uses element attribute contextref if it's not a reference to another element. Returns the date Keyword arguments: soup -- BeautifulSoup souped html/xml object each -- element of BeautifulSoup souped object """ # Try to find a date tag within the contextref element, # starting with the most specific tags, and starting with # those for ixbrl docs as it's the most common file. date_tag_list = ["xbrli:enddate", "xbrli:instant", "xbrli:period", "enddate", "instant", "period"] for tag in date_tag_list: try: date_str = each['contextref'] date_val = parser.parse(soup.find(id=each['contextref']).find(tag).get_text()). \ date(). \ isoformat() return (date_val) except: pass try: date_str = each.attrs['contextref'] date_val = parser.parse(each.attrs['contextref']). \ date(). \ isoformat() return (date_val) except: pass return ("NA") def parse_element(soup, element): """ For a discovered XBRL tagged element, go through, retrieve its name and value and associated metadata. Keyword arguments: soup -- BeautifulSoup object of accounts document element -- soup object of discovered tagged element """ if "contextref" not in element.attrs: return ({}) element_dict = {} # Basic name and value try: # Method for XBRLi docs first element_dict['name'] = element.attrs['name'].lower().split(":")[-1] except: # Method for XBRL docs second element_dict['name'] = element.name.lower().split(":")[-1] element_dict['value'] = element.get_text() element_dict['unit'] = retrieve_unit(soup, element) element_dict['date'] = retrieve_date(soup, element) # If there's no value retrieved, try raiding the associated context data if element_dict['value'] == "": element_dict['value'] = retrieve_from_context(soup, element.attrs['contextref']) # If the value has a defined unit (eg a currency) convert to numeric if element_dict['unit'] != "NA": element_dict['value'] = clean_value(element_dict['value']) # Retrieve sign of element if exists try: element_dict['sign'] = element.attrs['sign'] # if it's negative, convert the value then and there if element_dict['sign'].strip() == "-": element_dict['value'] = 0.0 - element_dict['value'] except: pass return (element_dict) def parse_elements(element_set, soup): """ For a set of discovered elements within a document, try to parse them. Only keep valid results (test is whether field "name" exists). Keyword arguments: element_set -- BeautifulSoup iterable search result object soup -- BeautifulSoup object of accounts document """ elements = [] for each in element_set: element_dict = parse_element(soup, each) if 'name' in element_dict: elements.append(element_dict) return (elements) def summarise_by_sum(doc, variable_names): """ Takes a document (dict) after extraction, and tries to extract a summary variable relating to the financial state of the enterprise by summing all those named that exist. Returns dict. Keyword arguments: doc -- an extracted document dict, with "elements" entry as created by the 'scrape_clean_elements' functions. variable_names - variables to find and sum if they exist """ # Convert elements to pandas df df = pd.DataFrame(doc['elements']) # Subset to most recent (latest dated) df = df[df['date'] == doc['doc_balancesheetdate']] total_assets = 0.0 unit = "NA" # Find the total assets by summing components for each in variable_names: # Fault-tolerant, will skip whatever isn't numeric try: total_assets = total_assets + df[df['name'] == each].iloc[0]['value'] # Retrieve reporting unit if exists unit = df[df['name'] == each].iloc[0]['unit'] except: pass return ({"total_assets": total_assets, "unit": unit}) def summarise_by_priority(doc, variable_names): """ Takes a document (dict) after extraction, and tries to extract a summary variable relating to the financial state of the enterprise by looking for each named, in order. Returns dict. Keyword arguments: doc -- an extracted document dict, with "elements" entry as created by the 'scrape_clean_elements' functions. variable_names - variables to find and check if they exist. """ # Convert elements to pandas df df = pd.DataFrame(doc['elements']) # Subset to most recent (latest dated) df = df[df['date'] == doc['doc_balancesheetdate']] primary_assets = 0.0 unit = "NA" # Find the net asset/liability variable by hunting names in order for each in variable_names: try: # Fault tolerant, will skip whatever isn't numeric primary_assets = df[df['name'] == each].iloc[0]['value'] # Retrieve reporting unit if it exists unit = df[df['name'] == each].iloc[0]['unit'] break except: pass return ({"primary_assets": primary_assets, "unit": unit}) def summarise_set(doc, variable_names): """ Takes a document (dict) after extraction, and tries to extract summary variables relating to the financial state of the enterprise by returning all those named that exist. Returns dict. Keyword arguments: doc -- an extracted document dict, with "elements" entry as created by the 'scrape_clean_elements' functions. variable_names - variables to find and return if they exist. """ results = {} # Convert elements to pandas df df = pd.DataFrame(doc['elements']) # Subset to most recent (latest dated) df = df[df['date'] == doc['doc_balancesheetdate']] # Find all the variables of interest should they exist for each in variable_names: try: results[each] = df[df['name'] == each].iloc[0]['value'] except: pass # Send the variables back to be appended return (results) def scrape_elements(soup, filepath): """ Parses an XBRL (xml) company accounts file for all labelled content and extracts the content (and metadata, eg; unitref) of each element found to a dictionary params: filepath (str) output: list of dicts """ # Try multiple methods of retrieving data, I think only the first is # now needed though. The rest will be removed after testing this # but should not affect execution speed. try: element_set = soup.find_all() elements = parse_elements(element_set, soup) if len(elements) <= 5: raise Exception("Elements should be gte 5, was {}".format(len(elements))) except: #if fails parsing create dummy entry elements so entry still exists in dictonary elements = [{'name': 'NA', 'value': 'NA', 'unit': 'NA', 'date': 'NA'}] pass return (elements) def flatten_data(doc): """ Takes the data returned by process account, with its tree-like structure and reorganises it into a long-thin format table structure suitable for SQL applications. """ # Need to drop components later, so need copy in function doc2 = doc.copy() doc_df = pd.DataFrame() # Pandas should create series, then columns, from dicts when called # like this if not isinstance(doc2['elements'], int): for element in doc2['elements']: doc_df = doc_df.append(element, ignore_index=True) # Dump the "elements" entry in the doc dict doc2.pop("elements") # Create uniform columns for all other properties for key in doc2: doc_df[key] = doc2[key] return (doc_df) def amp_correction(filepath): """ Looks for & symbol in html file and uses regex to strip out any instances that are not strictly amp; Named arguments: filepath -- complete filepath (string) from drive root """ #import re #open file as txt #file = open(filepath, 'r') #corrected_file = "" #for line in file: #line = line.strip() #print(line) #return file #too generalised! #determine if any lines need correcting #if re.search(r'&(?!amp;)',line) is not None: #print(line) #print message to show correction #print('file {} is being corrected for a misplaced & sign, may cause some strange parsing'.format(file)) #replace with acceptable syntax #line = re.sub(r'&(?!amp;)',r'&amp;',line) #append subbed lines back to file #corrected_file += line #return corrected file #return(corrected_file) def process_account(filepath): """ Scrape all of the relevant information from an iXBRL (html) file, upload the elements and some metadata to a mongodb. Named arguments: filepath -- complete filepath (string) from drive root """ doc = {} # Some metadata, doc name, upload date/time, archive file it came from doc['doc_name'] = filepath.split("/")[-1] doc['doc_type'] = filepath.split(".")[-1].lower() doc['doc_upload_date'] = str(datetime.now()) doc['arc_name'] = filepath.split("/")[-2] doc['parsed'] = True # Complicated ones sheet_date = filepath.split("/")[-1].split(".")[0].split("_")[-1] doc['doc_balancesheetdate'] = datetime.strptime(sheet_date, "%Y%m%d").date().isoformat() doc['doc_companieshouseregisterednumber'] = filepath.split("/")[-1].split(".")[0].split("_")[-2] try: soup = BS(open(filepath, "rb"), "html.parser") except: print("Failed to open: " + filepath) return (1) # Get metadata about the accounting standard used try: doc['doc_standard_type'], doc['doc_standard_date'], doc['doc_standard_link'] = retrieve_accounting_standard(soup) doc['parsed'] = True except: doc['doc_standard_type'], doc['doc_standard_date'], doc['doc_standard_link'] = (0, 0, 0) doc['parsed'] = False # Fetch all the marked elements of the document try: doc['elements'] = scrape_elements(soup, filepath) except Exception as e: doc['parsed'] = False doc['Error'] = e try: return (doc) except Exception as e: return (e) ###Output _____no_output_____ ###Markdown <div style=" width: 100%; height: 100px; border:none; background:linear-gradient(-45deg, d84227, ce3587); text-align: center; position: relative;"> <span style=" font-size: 40px; padding: 0 10px; color: white; margin: 0; position: absolute; top: 50%; left: 50%; -ms-transform: translate(-50%, -50%); transform: translate(-50%, -50%); font-weight: bold; "> EXTRACTION ###Code import os import numpy as np import pandas as pd import importlib import time import sys def get_filepaths(directory): """ Helper function - Get all of the filenames in a directory that end in htm* or xml. Under the assumption that all files within the folder are financial records. """ files = [directory + "/" + filename for filename in os.listdir(directory) if (("htm" in filename.lower()) or ("xml" in filename.lower()))] month_and_year = ('').join(directory.split('-')[-1:]) month, year = month_and_year[:-4], month_and_year[-4:] return files, month, year def progressBar(name, value, endvalue, bar_length = 50, width = 20): percent = float(value) / endvalue arrow = '-' * int(round(percent*bar_length) - 1) + '>' spaces = ' ' * (bar_length - len(arrow)) sys.stdout.write( "\r{0: <{1}} : [{2}]{3}% ({4} / {5})".format( name, width, arrow + spaces, int(round(percent*100)), value, endvalue ) ) sys.stdout.flush() if value == endvalue: sys.stdout.write('\n\n') def retrieve_list_of_tags(dataframe, column, output_folder): """ Save dataframe containing all unique tags to txt format in specified directory. Arguements: dataframe: tabular data column: location of xbrl tags output_folder: user specified file location Returns: None Raises: None """ list_of_tags = results['name'].tolist() list_of_tags_unique = list(set(list_of_tags)) print( "Number of tags in total: {}\nOf which are unique: {}".format(len(list_of_tags), len(list_of_tags_unique)) ) with open(output_folder + "/" + folder_year + "-" + folder_month + "_list_of_tags.txt", 'w') as f: for item in list_of_tags_unique: f.write("%s\n" % item) def get_tag_counts(dataframe, column, output_folder): """ Save dataframe containing all unique tags to txt format in specified directory. Arguements: dataframe: tabular data column: location of xbrl tags output_folder: user specified file location Returns: None Raises: None """ cache = dataframe cache["count"] = cache.groupby(by = column)[column].transform("count") cache.sort_values("count", inplace = True, ascending = False) cache.drop_duplicates(subset = [column, "count"], keep = "first", inplace = True) cache = cache[[column, "count"]] print(cache.shape) cache.to_csv( output_folder + "/" + folder_year + "-" + folder_month + "_unique_tag_frequencies.csv", header = None, index = True, sep = "\t", mode = "a" ) def build_month_table(list_of_files): """ """ process_start = time.time() # Empty table awaiting results results = pd.DataFrame() COUNT = 0 # For every file #for file in files: for file in files: COUNT += 1 # Read the file doc = process_account(file) # tabulate the results doc_df = flatten_data(doc) # append to table results = results.append(doc_df) progressBar("XBRL Accounts Parsed", COUNT, len(files), bar_length = 50, width = 20) print("Average time to process an XBRL file: \x1b[31m{:0f}\x1b[0m".format((time.time() - process_start) / 60, 2), "seconds") return results def output_xbrl_month(dataframe, output_folder, file_type = "csv"): """ Save dataframe to csv format in specified directory, with particular naming scheme "YYYY-MM_xbrl_data.csv". Arguments: dataframe: tabular data output_folder: user specified file destination Returns: None Raises: None """ if file_type == "csv": dataframe.to_csv( output_folder + "/" + folder_year + "-" + folder_month + "_xbrl_data.csv", index = False, header = True ) else: print("I need a CSV for now...") # Get all the filenames from the example folder files, folder_month, folder_year = get_filepaths("/shares/data/20200519_companies_house_accounts/xbrl_unpacked_data/Accounts_monthly_Data-July2010") print(len(files)) # Here you can splice/truncate the number of files you want to process for testing #files = files[791:793] print(folder_month, folder_year) ###Output July 2010 ###Markdown Use these commands to inspect portions of the XML data:```pythondoc = process_account(files[0:]) display for fundocdoc['elements'] Loop through the document, retrieving any element with a matching namefor element in doc['elements']: if element['name'] == 'balancesheetdate': print(element) Extract the all the data to long-thin table format for use with SQL Note, tables from docs should be appendable to one another to create tables of all dataflatten_data(doc).head(15)``` ###Code # Finally, build a table of all variables from all example (digital) documents # This can take a while results = build_month_table(files) print(results.shape) print(results.doc_name.drop_duplicates().count(),len(files)) results.head(10) # Hi Rob, # # Just checked several example batch files against the parser's outputs and QA checks, # the shape in the above cell is always exactly 1 less than the number of rows in the # outputted csv - as expected with the header row. # # Don't seem to get any error, and I've updated the methods in this notebook further. # # Let me know how you get on with this version! # # Elliott. output_xbrl_month(results, "/shares/data/20200519_companies_house_accounts/xbrl_parsed_data") # Find list of all unqiue tags in dataset list_of_tags = results["name"].tolist() list_of_tags_unique = list(set(list_of_tags)) print("Longest tag: ", len(max(list_of_tags_unique, key = len))) # Output all unqiue tags to a txt file retrieve_list_of_tags( results, "name", "/shares/data/20200519_companies_house_accounts/logs" ) # Output all unqiue tags and their relative frequencies to a txt file get_tag_counts( results, "name", "/shares/data/20200519_companies_house_accounts/logs" ) test_output_data = pd.read_csv("/shares/data/20200519_companies_house_accounts/xbrl_parsed_data/Accounts_monthly_Data-July2010", lineterminator = "\n") print(test_output_data.shape) ###Output _____no_output_____
visualization/SentimentDifferenceAnalysis.ipynb
###Markdown Sentiment Difference Visualizations ###Code import statistics as stat import numpy as np import pandas as pd import csv as csv import matplotlib.pyplot as mpl import os from tqdm import tqdm pwd = "/home/srivbane/shared/caringbridge/data/projects/sna-social-support/csv_data/" epoch_day = 86400000 # accounting for milliseconds with open(os.path.join(pwd, "from_inflection.csv"), 'r', encoding='utf-8') as infile: a_df = pd.read_csv(infile, header=0) from_df = a_df.fillna(0)[(a_df.pre_count.values > 5) & (a_df.post_count.values > 5)] with open(os.path.join(pwd, "to_inflection.csv"), 'r', encoding='utf-8') as infile: b_df = pd.read_csv(infile, header=0) to_df = b_df.fillna(0)[(b_df.pre_count.values > 5) & (b_df.post_count.values > 5)] with open(os.path.join(pwd, "overall_inflection.csv"), 'r', encoding='utf-8') as infile: c_df = pd.read_csv(infile, header=0) overall_df = c_df.fillna(0)[(c_df.pre_count.values > 5) & (c_df.post_count.values > 5)] em = 12 mpl.rcParams['figure.figsize'] = [9, 4] mpl.rcParams['figure.dpi'] = 300 mpl.rcParams['font.family'] = "serif" mpl.rcParams['font.size'] = 8 print(f"FROM: {len(a_df)} entries \t\t TO: {len(b_df)} entries \t\t OVERALL: {len(c_df)} entries ") print(f"FROM: {len(from_df)} valid entries \t TO: {len(to_df)} valid entries \t OVERALL: {len(overall_df)} valid entries ") ###Output FROM: 240034 entries TO: 246331 entries OVERALL: 274559 entries FROM: 47466 valid entries TO: 47385 valid entries OVERALL: 38688 valid entries ###Markdown Difference Plots ###Code fig, axs = mpl.subplots(1, 3, sharey=True) axs[0].hist(from_df.diff_pos, bins=30, range=(-.02, .02), color = 'b') axs[0].set_title(f"FROM ($\mu$ = {round(stat.mean(from_df.diff_pos.values), 4)})") axs[1].hist(to_df.diff_pos, bins=30, range=(-.02, .02), color = 'b') axs[1].set_title(f"TO ($\mu$ = {round(stat.mean(to_df.diff_pos.values), 4)})") axs[2].hist(overall_df.diff_pos, bins=30, range=(-.02, .02), color = 'b') axs[2].set_title(f"OVERALL ($\mu$ = {round(stat.mean(overall_df.diff_pos.values), 4)})") fig.suptitle("Positive Sentiment Difference for a Given Inflection", fontsize=em+2) mpl.show() fig, axs = mpl.subplots(1, 3, sharey=True) axs[0].hist(from_df.diff_neg, bins=30, range=(-.02, .02), color = 'r') axs[0].set_title(f"FROM ($\mu$ = {round(stat.mean(from_df.diff_neg.values), 4)})") axs[1].hist(to_df.diff_neg, bins=30, range=(-.02, .02), color = 'r') axs[1].set_title(f"TO ($\mu$ = {round(stat.mean(to_df.diff_neg.values), 4)})") axs[2].hist(overall_df.diff_neg, bins=30, range=(-.02, .02), color = 'r') axs[2].set_title(f"OVERALL ($\mu$ = {round(stat.mean(overall_df.diff_neg.values), 4)})") fig.suptitle("Negative Sentiment Difference for a Given Inflection", fontsize=em+2) mpl.show() ###Output _____no_output_____ ###Markdown Fitting the RegressionFit this to pre_pos, pre_count, the post_pre_count_ratio, tenure, pre_all_patient_author_ratio, and initiator_ratio. ###Code import statsmodels.api as sm import statsmodels.formula.api as smf dat = overall_df.copy() dat.head() with open(os.path.join(pwd, "dynamic_auth.csv"), 'r', encoding='utf-8') as auths: authors = pd.read_csv(auths, usecols=[0,2,3], names = ['user_id', 'first', 'last']) authors['tenure'] = ((authors["last"] - authors["first"]) / epoch_day) authors = authors[["user_id", "tenure"]] dat = pd.merge(dat, authors, on="user_id", how="left") dat["pre_pred_prop"] = np.divide(dat["pre_pa_count"], dat["pre_count"]) dat["inf_count_prop"] = np.divide(dat["post_count"], dat["pre_count"]) dat["single_author"] = [int(x > .9 or x < .1) for x in dat["pre_pred_prop"]] dat["patient_author"] = [int(x > .9) for x in dat["pre_pred_prop"]] dat.head() results = smf.ols('post_pos ~ pre_pos + pre_count + pre_pa_count + is_init + tenure + pre_pred_prop + inf_count_prop', data=dat).fit() print(results.summary()) corr = dat.corr() corr = corr.round(2) corr.style.apply(lambda x: ["background-color: yellow" if abs(v) > .1 else "" for v in x], axis = 1) ###Output _____no_output_____
supervised/random_forests.py.ipynb
###Markdown Bosques de arboles de desición ###Code import argparse import numpy as np import matplotlib.pyplot as plt from sklearn.metrics import classification_report from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import classification_report from utilities import visualize_classifier #Analizador de argumentos, dependiendo de la entrada #construimos un clisificador aleatorio o uno extremadamente aleatorio def build_arg_parser(): parser = argparse.ArgumentParser(description='Classify data using \ Ensemble Learning techniques') parser.add_argument('--classifier-type', dest='classifier_type', required=True, choices=['rf','erf'],help="Type of classifier \ to use, can be either 'rf' or 'erf'") return parser # Defición de función pricipar y analizar los argumentos de entrada """if __name__=='__main__': #analizar los argumentos de entrada args = build_arg_parser().parse_args() classifer_type = args.classifier_type """ def random_forests(type_forest, file): #Cargamos los datos input_file = file data = np.loadtxt(input_file, delimiter=',') X, y = data[:, :-1], data[:, -1] #Separamos los datos por etiquetas class_0 = np.array(X[y==0]) class_1 = np.array(X[y==1]) class_2 = np.array(X[y==2]) #Visualizar los datos de entrada plt.figure() plt.scatter(class_0[:,0], class_0[:, 1], s=75, facecolors='white', edgecolors='black', linewidth=1,marker='s') plt.scatter(class_1[:,0], class_1[:, 1], s=75, facecolors='white', edgecolors='black', linewidth=1,marker='o') plt.scatter(class_2[:,0], class_2[:, 1], s=75, facecolors='white', edgecolors='black', linewidth=1,marker='^') plt.title('Input data') #Dividir datos en entrenamiento y prueba X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.25, random_state=5) """Definimos los parámetros que se utilizarán cuando construyamos el clasificador. n_estimators: se refiere a la cantidad de árboles que se construirán. max_depth: se refiere al número máximo de niveles en cada árbol. random_state: se refiere al valor semilla del generador de números aleatorios necesario para inicializar el algoritmo de clasificador de bosque aleatorio. """ params = {'n_estimators':100, 'max_depth':4, 'random_state':0} if type_forest == 'rf': classifier = RandomForestClassifier(**params) else: classifier = ExtraTreesClassifier(**params) classifier.fit(X_train,y_train) print('\nTraining dataset\n') visualize_classifier(classifier, X_train, y_train,) #calculo de datos de salida en base a las entradas de prueba y_test_pred = classifier.predict(X_test) print('\nTest dataset\n') visualize_classifier(classifier, X_test, y_test) #Evaluación del clasificador # Evaluate classifier performance class_names = ['Class-0', 'Class-1', 'Class-2'] print("\n" + "#"*40) print("\nClassifier performance on training dataset\n") print(classification_report(y_train, classifier.predict(X_train),target_names=class_names)) print("#"*40 + "\n") print("#"*40) print("\nClassifier performance on test dataset\n") print(classification_report(y_test, y_test_pred,target_names=class_names)) print("#"*40 + "\n") #Estimar la medida de confianza de la predicción test_datapoints = np.array([[5, 5], [3, 6], [6, 4], [7, 2], [4, 4],[5, 2]]) print("\nConfidence measure:") for datapoint in test_datapoints: probabilities = classifier.predict_proba([datapoint])[0] predicted_class = 'Class-' + str(np.argmax(probabilities)) print('\nDatapoint:', datapoint) print('Predicted class:', predicted_class) # Visualize the datapoints print('\nTest datapoints\n') visualize_classifier(classifier, test_datapoints, [0]*len(test_datapoints)) #Clasificación bosque aleatorio random_forests('rf','data_random_forests.txt') #Clasificación bosque extremadamente aleatorio random_forests('erf','data_random_forests.txt') ###Output Training dataset
week8/ex7-kmeans and PCA/2- 2D kmeans.ipynb
###Markdown 2-2维kmeans ###Code import matplotlib.pyplot as plt import seaborn as sns import numpy as np import pandas as pd import scipy.io as sio mat = sio.loadmat('./data/ex7data2.mat') data2 = pd.DataFrame(mat.get('X'), columns=['X1', 'X2']) print(data2.head()) sns.set(context="notebook", style="white") sns.lmplot('X1', 'X2', data=data2, fit_reg=False) plt.show() ###Output X1 X2 0 1.842080 4.607572 1 5.658583 4.799964 2 6.352579 3.290854 3 2.904017 4.612204 4 3.231979 4.939894 ###Markdown 0. random initfor initial centroids ###Code def combine_data_C(data, C): data_with_c = data.copy() data_with_c['C'] = C return data_with_c # k-means fn -------------------------------- def random_init(data, k): """choose k sample from data set as init centroids Args: data: DataFrame k: int Returns: k samples: ndarray """ return data.sample(k).as_matrix() def _find_your_cluster(x, centroids): """find the right cluster for x with respect to shortest distance Args: x: ndarray (n, ) -> n features centroids: ndarray (k, n) Returns: k: int """ distances = np.apply_along_axis(func1d=np.linalg.norm, # this give you l2 norm axis=1, arr=centroids - x) # use ndarray's broadcast return np.argmin(distances) def assign_cluster(data, centroids): """assign cluster for each node in data return C ndarray """ return np.apply_along_axis(lambda x: _find_your_cluster(x, centroids), axis=1, arr=data.as_matrix()) def new_centroids(data, C): data_with_c = combine_data_C(data, C) return data_with_c.groupby('C', as_index=False).\ mean().\ sort_values(by='C').\ drop('C', axis=1).\ as_matrix() def cost(data, centroids, C): m = data.shape[0] expand_C_with_centroids = centroids[C] distances = np.apply_along_axis(func1d=np.linalg.norm, axis=1, arr=data.as_matrix() - expand_C_with_centroids) return distances.sum() / m def _k_means_iter(data, k, epoch=100, tol=0.0001): """one shot k-means with early break """ centroids = random_init(data, k) cost_progress = [] for i in range(epoch): print('running epoch {}'.format(i)) C = assign_cluster(data, centroids) centroids = new_centroids(data, C) cost_progress.append(cost(data, centroids, C)) if len(cost_progress) > 1: # early break if (np.abs(cost_progress[-1] - cost_progress[-2])) / cost_progress[-1] < tol: break return C, centroids, cost_progress[-1] def k_means(data, k, epoch=100, n_init=10): """do multiple random init and pick the best one to return Args: data (pd.DataFrame) Returns: (C, centroids, least_cost) """ tries = np.array([_k_means_iter(data, k, epoch) for _ in range(n_init)]) least_cost_idx = np.argmin(tries[:, -1]) return tries[least_cost_idx] random_init(data2, 3) ###Output _____no_output_____ ###Markdown 1. cluster assignmenthttp://stackoverflow.com/questions/14432557/matplotlib-scatter-plot-with-different-text-at-each-data-point find closest cluster experiment ###Code init_centroids = random_init(data2, 3) init_centroids x = np.array([1, 1]) fig, ax = plt.subplots(figsize=(6,4)) ax.scatter(x=init_centroids[:, 0], y=init_centroids[:, 1]) for i, node in enumerate(init_centroids): ax.annotate('{}: ({},{})'.format(i, node[0], node[1]), node) ax.scatter(x[0], x[1], marker='x', s=200) plt.show() _find_your_cluster(x, init_centroids) ###Output _____no_output_____ ###Markdown 1 epoch cluster assigning ###Code C = assign_cluster(data2, init_centroids) data_with_c =combine_data_C(data2, C) data_with_c.head() ###Output _____no_output_____ ###Markdown See the first round clustering result ###Code sns.lmplot('X1', 'X2', hue='C', data=data_with_c, fit_reg=False) plt.show() ###Output _____no_output_____ ###Markdown 2. calculate new centroid ###Code new_centroids(data2, C) ###Output _____no_output_____ ###Markdown putting all together, take1this is just 1 shot `k-means`, if the random init pick the bad starting centroids, the final clustering may be very sub-optimal ###Code final_C, final_centroid, _= _k_means_iter(data2, 3) data_with_c = combine_data_C(data2, final_C) sns.lmplot('X1', 'X2', hue='C', data=data_with_c, fit_reg=False) plt.show() ###Output _____no_output_____ ###Markdown calculate the cost ###Code cost(data2, final_centroid, final_C) ###Output _____no_output_____ ###Markdown k-mean with multiple tries of randome init, pick the best one with least cost ###Code best_C, best_centroids, least_cost = k_means(data2, 3) least_cost data_with_c = combine_data_C(data2, best_C) sns.lmplot('X1', 'X2', hue='C', data=data_with_c, fit_reg=False) plt.show() ###Output _____no_output_____ ###Markdown try sklearn kmeans ###Code from sklearn.cluster import KMeans sk_kmeans = KMeans(n_clusters=3) sk_kmeans.fit(data2) sk_C = sk_kmeans.predict(data2) data_with_c = combine_data_C(data2, sk_C) sns.lmplot('X1', 'X2', hue='C', data=data_with_c, fit_reg=False) plt.show() ###Output _____no_output_____
avacado_Data_Analysis (1).ipynb
###Markdown a. How the prices of avocado vary from time to time A - SanFrancisco ###Code data["Date"]=pd.to_datetime(data["Date"],format='%Y-%m-%d') data["Year"]=data["Date"].dt.year data["Month"]=data["Date"].dt.month data["Day"]=data["Date"].dt.day data=data.sort_values(["Year","Month","Day"]) data.head(3) Region_grouped = data.groupby('Date')['AveragePrice'].mean().reset_index() Region_grouped.head() Region_grouped plt.figure(figsize=(20,6)) plt.plot(Region_grouped['Date'], Region_grouped['AveragePrice'], label='Average Price variationwith Time', linewidth=2, color='blue') plt.legend() ###Output _____no_output_____ ###Markdown b. Which Areas sell avocado at a very high price A- HartfordSpringfield ###Code data[['Date','region']].duplicated() data_regionwise = data.groupby('region')['AveragePrice'].mean() data_regionwise = pd.DataFrame(data_regionwise) data_regionwise.dtypes data_regionwise[data_regionwise['AveragePrice']==data_regionwise['AveragePrice'].max()] ###Output _____no_output_____ ###Markdown c. In which year, the prices of avocado were the highest A - 2017 ###Code data.head(3) data_yearwise = data.groupby('year')['AveragePrice'].mean().reset_index() data_yearwise.head() data_yearwise.sort_values('AveragePrice', ascending=False) ###Output _____no_output_____ ###Markdown d. Which areas are having highest demand for avocado A - TotalUS ###Code data.head(3) data_Demandwsie = data.groupby('region')['Total Bags'].sum() data_Demandwsie = pd.DataFrame(data_Demandwsie) data_Demandwsie.sort_values('Total Bags', ascending=False).head() ###Output _____no_output_____ ###Markdown e. Which type of avocado is more popular A - conventional ###Code data.head(3) data_typewise = data.groupby('type')['Total Volume'].sum().reset_index() data_typewise.sort_values('Total Volume', ascending=False) ###Output _____no_output_____
.ipynb_checkpoints/plink_data_analysis-checkpoint.ipynb
###Markdown Manhattan Plot ###Code from bioinfokit import analys, visuz df_ = analys.get_data("mhat").data df_.head() #df.TEST.unique() df.head() ###Output _____no_output_____ ###Markdown Save default ###Code # Create Manhattan plot with default parameters visuz.marker.mhat(df= df, chr = "CHR", pv="P") #visuz.marker.mhat(df=df_, chr='chr',pv='pvalue') ###Output _____no_output_____ ###Markdown Change Colors ###Code visuz.marker.mhat(df = df, chr = "CHR", pv = "P", color= ("red", "green")) # to keep colors in all Chromosome, We need Chromosome Number length df["CHR"].nunique() # we need to pass 23 Colors # Add Different Colors equal to number of Chromosome colors = ["red", "yellow","#a7414a", "#696464", "#00743f", "#563838", "#6a8a82", "#a37c27", "#5edfff", "#282726", "#c0334d", "#c9753d", "red", "yellow","#a7414a", "#696464", "#00743f", "#563838", "#6a8a82", "#a37c27", "#5edfff", "#282726", "#c0334d"] visuz.marker.mhat(df = df, chr = "CHR", pv= "P", color=colors) print(len(colors)) # The Number of Colors must be same with Chromosome Unique type ###Output 23 ###Markdown Add Genome-Wide significance line, ###Code ## By default line will plotted at P=5E-0.8 # We can change this value as per need visuz.marker.mhat(df = df, chr="CHR", pv= "P", color=colors, gwas_sign_line=True) # Line will not display if the P value is so small ###Output _____no_output_____ ###Markdown Change LIne with user input ###Code # Change the position of genome-wide significance lin # You can change this value as per need visuz.marker.mhat(df=df, chr="CHR", pv = "P", color=colors, gwas_sign_line=True, gwasp=5E-04) # gwasp line will not show if p value to high ###Output _____no_output_____ ###Markdown Add annotation to SNPs (default text) ###Code # Add name to SNPs based on the significance defined by "Gwasp" visuz.marker.mhat(df= df, chr= "CHR", pv = "P", color=colors, gwas_sign_line=True, gwasp=5E-04, markernames=True, markeridcol="SNP") ## This is Time Consuming, It took me around 10 min 32 GB Ram and 12 core ###Output _____no_output_____ ###Markdown Add annotation to SNPs (box text) ###Code # Add name to SNPs based on the significance defined by gwasp visuz.marker.markerhat(df = df, chr = "CHR", pv = "P", color = colors, gwas_sign_line = True, gwasp = 5E-06, markernames = True, markeridcol = "SNP", gstyle = 2) ###Output _____no_output_____ ###Markdown The Below are sample data presenting mataplot ###Code from pandas import DataFrame from scipy.stats import uniform from scipy.stats import randint import numpy as np ## Some Sample data df = DataFrame({"gene":["gene-%i" % i for i in np.arange(10000)], "pvalue":uniform.rvs(size = 10000), "Chromosome": ["ch-%i" %i for i in randint.rvs(0,12, size = 10000)]}) df.head() df['minuslog10pvalue'] = -np.log10(df.pvalue) df = df.sort_values("Chromosome") df.head() df.tail() df["ind"] = range(len(df)) df.reset_index(drop=True, inplace=True) df df_grouped = df.groupby(("Chromosome")) fig = plt.figure(figsize=(20,10)) ax = fig.add_subplot(111) colors = ['red','green','blue', 'yellow'] for num, (name, group) in enumerate(df_grouped): group.plot(kind = "scatter", x = "ind", y = "minuslog10pvalue",\ color = colors[num % len(colors)], ax = ax) x_labels.append(name) x_labels_pos.append((group["ind"].iloc[-1]- (group["ind"].iloc[-1] - group["ind"].iloc[-1])/2)) ax.set_xticks(x_labels_pos) ax.set_xticklabels(x_labels) ax.set_xlim([0, len(df)]) ax.set_xlabel("Chromosome") from pandas import DataFrame from scipy.stats import uniform from scipy.stats import randint import numpy as np import matplotlib.pyplot as plt # some sample data df = DataFrame({'gene' : ['gene-%i' % i for i in np.arange(10000)], 'pvalue' : uniform.rvs(size=10000), 'chromosome' : ['ch-%i' % i for i in randint.rvs(0,12,size=10000)]}) # -log_10(pvalue) df['minuslog10pvalue'] = -np.log10(df.pvalue) df.chromosome = df.chromosome.astype('category') df.chromosome = df.chromosome.cat.set_categories(['ch-%i' % i for i in range(12)], ordered=True) df = df.sort_values('chromosome') # How to plot gene vs. -log10(pvalue) and colour it by chromosome? df['ind'] = range(len(df)) df_grouped = df.groupby(('chromosome')) fig = plt.figure(figsize=(20,10)) ax = fig.add_subplot(111) colors = ['red','green','blue', 'yellow'] x_labels = [] x_labels_pos = [] for num, (name, group) in enumerate(df_grouped): group.plot(kind='scatter', x='ind', y='minuslog10pvalue',color=colors[num % len(colors)], ax=ax) x_labels.append(name) x_labels_pos.append((group['ind'].iloc[-1] - (group['ind'].iloc[-1] - group['ind'].iloc[0])/2)) ax.set_xticks(x_labels_pos) ax.set_xticklabels(x_labels) ax.set_xlim([0, len(df)]) ax.set_ylim([0, 3.5]) ax.set_xlabel('Chromosome') import matplotlib.pyplot as plt from numpy.random import randn, random_sample g = random_sample(int(1e5))*10 # Uniform random values between 0 and 10 p = abs(randn(int(1e5))) # Abs of Normally distributed data """ plot g vs p in groups with different colors colors are cycled automatically by matplotlib use another colormap or define own colors for a different cycle """ plt.figure(figsize=(20,10)) for i in range(1, 11): plt.plot(g[abs(g-i)< 1], p[abs(g-i)< 1], ls = "", marker = ".") plt.show() ###Output _____no_output_____
model/Simple_CNN_CWE476.ipynb
###Markdown Data Preprocessing ###Code # Loading formatted data # I use format the data into pd dataframe # See data_formatting.ipynb for details train_data = pd.read_pickle("../dataset/train.pickle") validate_data = pd.read_pickle("../dataset/validate.pickle") test_data = pd.read_pickle("../dataset/test.pickle") ###Output _____no_output_____ ###Markdown Tokenize the source code BoW For data batching convenience, the paper trained only on functions with token length $10 \leq l \leq 500$, padded to the maximum length of **500** The paper does not mention to pad the 0 at the end or at the beginning, so I assume they append the padding at the end (actually, this is not a big deal in CNN) text_to_word_sequence does not work since it ask a single string ###Code # train_tokenized = tf.keras.preprocessing.text.text_to_word_sequence(train_data[0]) # x_train = tf.keras.preprocessing.sequence.pad_sequences(train_tokenized, maxlen=500, padding="post") # validate_tokenized = tf.keras.preprocessing.text.text_to_word_sequence(validate_data[0]) # x_validate = tf.keras.preprocessing.sequence.pad_sequences(validate_tokenized, maxlen=500, padding="post") # test_tokenized = tf.keras.preprocessing.text.text_to_word_sequence(test_data[0]) # x_test = tf.keras.preprocessing.sequence.pad_sequences(test_tokenized, maxlen=500, padding="post") ###Output _____no_output_____ ###Markdown Init the Tokenizer BoW ###Code # The paper does not declare the num of words to track, I am using 10000 here tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=10000) # Required before using texts_to_sequences # Arguments; a list of strings tokenizer.fit_on_texts(list(train_data[0])) ###Output _____no_output_____ ###Markdown For data batching convenience, the paper trained only on functions with token length $10 \leq l \leq 500$, padded to the maximum length of **500** The paper does not mention to pad the 0 at the end or at the beginning, so I assume they append the padding at the end (actually, this is not a big deal in CNN) ###Code train_tokenized = tokenizer.texts_to_sequences(train_data[0]) x_train = tf.keras.preprocessing.sequence.pad_sequences(train_tokenized, maxlen=500, padding="post") validate_tokenized = tokenizer.texts_to_sequences(validate_data[0]) x_validate = tf.keras.preprocessing.sequence.pad_sequences(validate_tokenized, maxlen=500, padding="post") test_tokenized = tokenizer.texts_to_sequences(test_data[0]) x_test = tf.keras.preprocessing.sequence.pad_sequences(test_tokenized, maxlen=500, padding="post") y_train = train_data[train_data.columns[4]].astype(int) y_validate = validate_data[validate_data.columns[4]].astype(int) y_test = test_data[test_data.columns[4]].astype(int) ###Output _____no_output_____ ###Markdown Model Design This dataset is highly imbalanced, so I am working on adjusting the train weightshttps://www.tensorflow.org/tutorials/structured_data/imbalanced_data ###Code clear, vulnerable = (train_data[train_data.columns[4]]).value_counts() total = vulnerable + clear print("Total: {}\n Vulnerable: {} ({:.2f}% of total)\n".format(total, vulnerable, 100 * vulnerable / total)) weight_for_0 = (1 / clear)*(total)/2.0 weight_for_1 = (1 / vulnerable)*(total)/2.0 class_weight = {0: weight_for_0, 1: weight_for_1} print('Weight for class 0: {:.2f}'.format(weight_for_0)) print('Weight for class 1: {:.2f}'.format(weight_for_1)) model = tf.keras.Sequential() model.add(tf.keras.layers.Embedding(input_dim=10000, output_dim=13, input_length=500)) model.add(tf.keras.layers.Conv1D(filters=512, kernel_size=9, activation="relu")) model.add(tf.keras.layers.MaxPool1D(pool_size=4)) model.add(tf.keras.layers.Dropout(rate=0.5)) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(units=64, activation="relu")) model.add(tf.keras.layers.Dense(units=16, activation="relu")) # I am using the sigmoid rather than the softmax mentioned in the paper model.add(tf.keras.layers.Dense(units=1, activation="sigmoid")) # Adam Optimization with the parameter stated in the paper adam = tf.keras.optimizers.Adam(lr=0.0002) # Define the evaluation metrics METRICS = [ tf.keras.metrics.TruePositives(name='tp'), tf.keras.metrics.FalsePositives(name='fp'), tf.keras.metrics.TrueNegatives(name='tn'), tf.keras.metrics.FalseNegatives(name='fn'), tf.keras.metrics.BinaryAccuracy(name='accuracy'), tf.keras.metrics.Precision(name='precision'), tf.keras.metrics.Recall(name='recall'), tf.keras.metrics.AUC(name='auc'), ] model.compile(optimizer=adam, loss="binary_crossentropy", metrics=METRICS) model.summary() history = model.fit(x=x_train, y=y_train, batch_size=128, epochs=10, verbose=1, class_weight=class_weight, validation_data=(x_validate, y_validate)) with open('CWE476_trainHistory', 'wb') as history_file: pickle.dump(history.history, history_file) model.save("Simple_CNN_CWE476") results = model.evaluate(x_test, y_test, batch_size=128) ###Output _____no_output_____
ClassExercises/Week1_Adventure/pyAdventureSolution.ipynb
###Markdown Adventure Time SolutionBelow is a solution that uses a dictionary whose keys are the place locations and whose values are themselves dictionaries with two keys/value pairs: the description of that location and a list of places that one can go next. So a dictionary within a dictionary (dict-ception). For instance, a data structure with one entry in the dictionary might look like this ###Code places = {"Office":{ "description":"The place where you frantically try to get everything ready for class", "next":["Kitchen", "Bathroom"] }} print(places["Office"]["description"]) # Print out the description ###Output The place where you frantically try to get everything ready for class ###Markdown Some students chose to make the value a list instead of a dictionary, which is fine. The only downside is we now need to use some magic number indices to access the description and next place, so it is stylistically not quite as elegant ###Code places = {"Office":["The place where you frantically try to get everything ready for class", ["Kitchen", "Bathroom"]]} ###Output _____no_output_____ ###Markdown Matching braces can be a real pain when we have nested lists/dictionaries like this, so I'm going to break it down by starting over and adding elements one at a time ###Code places = {} places["Office"] = {"description":"The place where you frantically try to get everything ready for class", "next":["Kitchen", "Bathroom"]} places["Bathroom"] = {"description":"The place you go when nature calls", "next":["Office"]} places["Kitchen"] = {"description":"The place where you heat up frozen food and sometimes (but rarely) cook", "next":["Office", "Upstairs Bedroom", "Outside"]} places["Outside"] = {"description":"The place you will go when there is a COVID vaccine", "next":["Kitchen"]} places["Upstairs Bedroom"] = {"description":"The place you go rarely when you've finished your work for the day", "next":["Kitchen", "Upstairs Bathroom"]} places["Upstairs Bathroom"] = {"description":"The higher altitude version of the place you go when nature calls", "next":["Kitchen", "Upstairs Bedroom"]} ###Output _____no_output_____ ###Markdown Finally, we can put this together in a while loop that's our game. We'll make the game end when we end up outside ###Code start = "Office" end = "Outside" state = start while state != end: print("You are at ", state, ".", places[state]["description"]) nxt = "" while len(nxt) == 0: # Keep looping until we get a valid input print("Please type your next destination", places[state]["next"], ":") nxt = input() if nxt in places[state]["next"]: state = nxt else: print("Invalid next location!") nxt = "" print("You have arrived at ", end, ".", places[end]["description"]) ###Output You are at Office . The place where you frantically try to get everything ready for class Please type your next destination ['Kitchen', 'Bathroom'] : Bathroom You are at Bathroom . The place you go when nature calls Please type your next destination ['Office'] : Office You are at Office . The place where you frantically try to get everything ready for class Please type your next destination ['Kitchen', 'Bathroom'] : Kitchen You are at Kitchen . The place where you heat up frozen food and sometimes (but rarely) cook Please type your next destination ['Office', 'Upstairs Bedroom', 'Outside'] : Office You are at Office . The place where you frantically try to get everything ready for class Please type your next destination ['Kitchen', 'Bathroom'] : Kitchen You are at Kitchen . The place where you heat up frozen food and sometimes (but rarely) cook Please type your next destination ['Office', 'Upstairs Bedroom', 'Outside'] : blah Invalid next location! Please type your next destination ['Office', 'Upstairs Bedroom', 'Outside'] : Upstairs bedroom Invalid next location! Please type your next destination ['Office', 'Upstairs Bedroom', 'Outside'] : Upstairs Bedroom You are at Upstairs Bedroom . The place you go rarely when you've finished your work for the day Please type your next destination ['Kitchen', 'Upstairs Bathroom'] : Upstairs Bathroom You are at Upstairs Bathroom . The higher altitude version of the place you go when nature calls Please type your next destination ['Kitchen', 'Upstairs Bedroom'] : Upstairs Bedroom You are at Upstairs Bedroom . The place you go rarely when you've finished your work for the day Please type your next destination ['Kitchen', 'Upstairs Bathroom'] : Kitchen You are at Kitchen . The place where you heat up frozen food and sometimes (but rarely) cook Please type your next destination ['Office', 'Upstairs Bedroom', 'Outside'] : Outside You have arrived at Outside . The place you will go when there is a COVID vaccine
notebooks/nb.ipynb
###Markdown demo notebook ###Code from demo import utils feet = 5.5 meters = utils.feet_to_meters(feet) meters ###Output _____no_output_____
1ST PROJECT/1ST PROJECT.ipynb
###Markdown CRYPTOGRAPHY Cryptography means converting a simple plain text into something which is not understandable easy until someone has the KEY or Code and vice-versaCipher Text -> A text which is the result of Encryption is knows as Cipher TextEncryption -> Converting a message to Secret message is known as EncrytpionDecryption -> Converting back the Secret messege to Normal Message ###Code # Write a Python Program which converts, Any Given Text to Chiper Text and when every the key is avalible it should convert it back to the Normal Message #Step 1 - > Which Library to use to convert a Normal text to Chiper Text #Step 2 -> Take Input from the User and convert it to Chiper Text #Step 3 -> Display back the Chiper Text to user #Step 4 -> Load the Key and If the Key is the same, based upon the Input provided, convert it to normal Text #installing the cryptography library from pypi !pip install cryptography from cryptography.fernet import Fernet #Function to generate password key def genratePassKey(): key = Fernet.generate_key() abc = open("PasswordKey.key",'wb') #This is for opening the 'abc' file which indicates that the file is opened for writing in binary mode abc.write(key) # wriiting in anything in key abc.close() #closing the file abc genratePassKey() #calling the function #function which show generated key def getMyKey(): abc = open("PasswordKey.key",'rb') #file read-only mode in binary format. The pointer is at the beginning of the file. return abc.read() getMyKey() # function to take any string which is we want to encrypt def getContentFromUser(): return bytes(input("Enter key to ENCRYPT : "),'utf-8') userinp = getContentFromUser() #function which encrypt the inputed message def encryptMessage(message_normal): key = getMyKey() k = Fernet(key) encrypted_Message = k.encrypt(message_normal) return encrypted_Message encryptedmsg = encryptMessage(bytes(userinp)) #function to decryptmessage def decryptMessage(message_secret): key = getMyKey() k = Fernet(key) decrypted_Message = k.decrypt(message_secret) return decrypted_Message decryptMessage(encryptedmsg).decode('utf-8') ###Output _____no_output_____
pymaceuticals-plotting.ipynb
###Markdown The Power of Plots Matplotlib Homework Assignment Author: Alex Schanne In this assignment, we will be working for Pymaceuticals Inc. on their most recent animal study. We will be generating all the tables and figures needed for the technical report of the study. Additionally we will provide a summary of our results at the end. More specifically this report will: Clean all the data for duplicates. Generate a statistical summary of the data, including mean, median, variance, standard deviation and SEM of the tumor volume in each drug regimen. Use Panda's DataFrame and Matplotlib's Pyplot to visualize. Calculate the final tumor volume of each mouse across the four most promising treatment regimens: Capomulin, Ramicane, Infubinol, and Ceftamin, in order to look at the quartiles and determine outliers. Create a Box and Whiskers plot of the final tumor volume for all four treatment regimens and highlight any potential outliers in distict color and style. Select a Capomulin mouse and generate a plot of time versus tumor volume. Generate a scatter plot of mouse weight versus average tumor volume for Capomulin. And calculate the correlation coefficient and linear regression model for that relationship. Trends and Observations First ObservationThe first thing we notice when we take a look at this study is the subject population. They carefully tried to keep the population half and half male-female and equal for each drug regimen. So at least superficially (without knowing any other attributes of the population) that the trial was trying to be 'fair' for each regimen. The only regimen that did not have 25 mouse subjects was Stelasyn. Second ObservationAnother immediate observation we can make about this data is from the data summary of tumor volume over time. We see that the variance in tumor volume is low to start but seem to increase throughout the timepoints. This is to be expected if we are to believe that the study was set up correctly and we are seeing how each mouse responds to the treatment idiosyncratically. In any experiment, setting the initial conditions, in this case ensuring approximately equal tumor volumes in the mice, will allow a better measurement of how different variables are affected by the controlled variables. For instance the mouse population in the Capomulin treatment group, show a 0.00 variance at timepoint 0, but by timepoint 45, they show a variance of 19.035028. Third ObservationAnother thing we notice is the range and skew of the weight data for the top two of the top four drugs seem to be smaller and lower. Or rather, their range is not as large. Neither Capomulin or Ramicane have outliers and their interquartile range is below 10, meaning the majority of the mice's weights data falls within 10 mm3 of each other. Additionally the mice of those regimen's weigh, on average, less than the mice of the other regimens. *This seems to suggest that lower weight is a positive outcome of the drug treatments. This is not explicitly stated. So it should be noted that this is only inferred. Any conclusions based on this assumption should be re-evaluated, and not be considered final. Setting up and Cleaning the Data ###Code #Importing dependencies and doing pre-work import pandas as pd import numpy as np import matplotlib.pyplot as plt import scipy.stats as st import plotly.graph_objects as go import plotly.offline as pyo #importing files and creating Dataframes mouse_path = "data/Mouse_metadata.csv" results_path = "data/Study_results.csv" mouse_pd = pd.read_csv(mouse_path) study_pd = pd.read_csv(results_path) #merging dataframes into one, on 'Mouse ID' stewart_little = pd.merge(mouse_pd, study_pd, on = "Mouse ID") #Cleaning the columns names to ameliorate typing mouse_study = stewart_little.rename(columns = {'Mouse ID': 'mouse_id', 'Drug Regimen': 'drug', 'Sex': 'sex', 'Age_months': 'age', 'Weight (g)': 'weight', 'Timepoint': 'timepoint', 'Tumor Volume (mm3)': 'tumor_volume', 'Metastatic Sites': 'metastatic_sites'}) mouse_study.head() #Checking amount of data in study versus how many unique mouse ids are included in the study print(len(mouse_study), mouse_study['mouse_id'].nunique()) #Checking the number of different drug regimens mouse_study['drug'].value_counts() #Dropping the duplicate mice rows and keeping their initial row clean_complete = mouse_study.drop_duplicates(subset = 'mouse_id', keep = 'first', inplace = False) clean_complete.head() print(clean_complete['mouse_id'].count()) print(clean_complete['drug'].value_counts()) ###Output 249 Infubinol 25 Zoniferol 25 Ramicane 25 Propriva 25 Capomulin 25 Placebo 25 Ceftamin 25 Naftisol 25 Ketapril 25 Stelasyn 24 Name: drug, dtype: int64 ###Markdown Summary Statistics Now that we have created clean dataframes, combining the study results and the mice data, we will quickly go over a statistical summary of the data. That way we have a better understanding of the data's narrative and are better prepared to do more in-depth analysis later. ###Code #Generating a summary statistics table for the tumor volume for each regimen drug_group = mouse_study.set_index("timepoint").groupby(['drug', 'timepoint']).agg({'tumor_volume': ['mean', 'median', 'var', 'std', 'sem']}) drug_group ###Output _____no_output_____ ###Markdown Bar and Pie Charts Now that we have a clear summary of each drug's performance as measured by tumor volume (mm3), we can start to plot some of the key behaviors and trends we want to analyze. First we will visualize with Bar and Pie charts. ###Code #Pandas: Generating a bar plot showing the total number of mice for each treatment throughout study. #creating the dataframe x_axis = clean_complete['drug'].unique().tolist() y_axis = clean_complete.groupby(['drug'])['mouse_id'].count().tolist() drug_mouse = pd.DataFrame({'drug':x_axis, 'mice': y_axis}) #creating the plot and formatting to match the last subject_plot = drug_mouse.plot(kind = "bar", figsize = (12,7), color = 'g') subject_plot.get_xticks() subject_plot.set_xticklabels(drug_mouse['drug']) subject_plot.set_title('The Number of Mice in Each Drug Regimen') subject_plot.set_xlabel('Drug Regimen') subject_plot.set_ylabel('Number of Mice in per Regimen in Trial') subject_plot.set_xlim(-1, len(x_axis)) subject_plot.set_ylim(0, max(y_axis) + 5) #saving and showing bar chart plt.savefig('charts/drugsubjects_barchart1') plt.show() #Matplotlib: Generating a bar plot showing the total number of mice for each treatment throughout study. x_axis = clean_complete['drug'].unique().tolist() y_axis = clean_complete.groupby(['drug'])['mouse_id'].count().tolist() #Creating and formatting the figure plt.figure(figsize = (12,7)) plt.bar(x_axis, y_axis, color = 'g', align = 'center') plt.xlabel("Drug Regimens") plt.ylabel("Number of Mice in per Regimen in Trial") plt.title("The Number of Mice in Each Drug Regimen") plt.xlim(-1, len(x_axis)) plt.ylim(0, max(y_axis) + 5) #saving and showing bar chart plt.savefig('charts/drugsubjects_barchart2') plt.show() #Pandas: Generating a pie chart showing male vs female subjects for each treatment throughout study. #the data to be used gender_group = clean_complete.groupby(['sex']).count()[['mouse_id']] labels = clean_complete['sex'].unique().tolist() #creating the pie chart gender_group.plot.pie(subplots = True, explode = (0, 0.1), labels = labels, autopct="%1.1f%%", figsize = (5,5), shadow = True) plt.ylabel('Sex') plt.title('Male vs. Female Subjects in Study Population') #saving and showing pie chart plt.savefig('charts/subjectsex_piechart1') plt.show() #Matplotlib: Generating a pie chart showing male vs female subjects for each treatment throughout study. fig, ax = plt.subplots() ax.pie(gender_group, explode = (0, 0.1), labels = labels, autopct="%1.1f%%", shadow = True) ax.set_ylabel('Sex') ax.set_title('Male vs. Female Subjects in Study Population') #showing pie chart plt.savefig('charts/subjectsex_piechart2') plt.show() ###Output C:\Users\alexs\anaconda3\envs\PythonData\lib\site-packages\ipykernel_launcher.py:3: MatplotlibDeprecationWarning: Non-1D inputs to pie() are currently squeeze()d, but this behavior is deprecated since 3.1 and will be removed in 3.3; pass a 1D array instead. ###Markdown Quartiles, Outliers and Boxplots Now that we have looked more closely at our study population, we move on to the data range. We will look at the skew of our data, where most of our data lies with its range and we will look to see if there are any outliers in our data. ###Code # Calculate the final tumor volume of each mouse across four of the treatment regimens: # Capomulin, Ramicane, Infubinol, and Ceftamin # Start by getting the last (greatest) timepoint for each mouse last_time = mouse_study.drop_duplicates(subset = 'mouse_id', keep = 'last', inplace = False) # Merge this group df with the original dataframe to get the tumor volume at the last timepoint top4 = last_time[(last_time['drug'] == 'Capomulin') | (last_time['drug'] == 'Ramicane') | (last_time['drug'] == 'Infubinol') | (last_time['drug'] == 'Ceftamin')] top4 # Put treatments into a list for for loop (and later for plot labels) regimens = top4['drug'].tolist() # Create empty list to fill with tumor vol data (for plotting) vol_data = [] outlier_list = [] # Calculate the IQR and quantitatively determine if there are any potential outliers. quartiles = top4['tumor_volume'].quantile([.25,.5,.75]) lowerq = quartiles[.25] upperq = quartiles[.75] iqr = upperq-lowerq #Finding outliers with pandas function def outliers(df): lower_bound = lowerq - (1.5*iqr) upper_bound = upperq + (1.5*iqr) tum_vol = top4['tumor_volume'] for volume in tum_vol: if volume > upper_bound or volume < lower_bound: outlier_list.append(volume) vol_data.append(volume) else: vol_data.append(volume) return outlier_list outliers(top4) #Printing out results of Quartile and Outlier Analysis print(f"The lower quartile of the tumor volume data is: {lowerq}.") print(f"The upper quartile of the tumor volume data is: {upperq}.") print(f"The interquartile range of the tumor volume data is: {iqr}.") print(f"The the median of the tumor volume data is: {quartiles[0.5]}.") if len(outlier_list) != 0: print(f"The full dataset for tumor volume in all regimens contains the following outlier(s):" + str(outlier_list)) else: print("There are no outliers in the Tumor Volume data for the top four regimens.") #This is a Box and Whiskers Plot for the data for all 4 regimens. It will be a guide for the green_diamond = dict(markerfacecolor='g', marker='D') fig1, ax1 = plt.subplots() ax1.set_title('Final Tumor Volume in All Regimens') ax1.set_ylabel('Final Tumor Volume (mm3)') ax1.boxplot(vol_data, flierprops=green_diamond) plt.show() #Analyzing the Quartiles and Outliers of Capomulin #Capomulin DataFrame capo_data = top4[top4['drug'].isin(['Capomulin'])] #Creating Empty lists for to loop through for plotting capo_vol = [] capo_outliers = [] # Calculate the IQR and quantitatively determine if there are any potential outliers. quartiles = capo_data['tumor_volume'].quantile([.25,.5,.75]) capo_lowerq = quartiles[.25] capo_upperq = quartiles[.75] capo_iqr = capo_upperq-capo_lowerq #Finding outliers with pandas function def outliers(df): lower_bound = capo_lowerq - (1.5*capo_iqr) upper_bound = capo_upperq + (1.5*capo_iqr) tum_vol = capo_data['tumor_volume'] for volume in tum_vol: if volume > upper_bound or volume < lower_bound: capo_outliers.append(volume) capo_vol.append(volume) else: capo_vol.append(volume) return capo_outliers outliers(capo_data) print(f"The lower quartile of Capomulin's tumor volume data is: {capo_lowerq}") print(f"The upper quartile of Capomulin's tumor volume is: {capo_upperq}") print(f"The interquartile range of Capomulin's tumor volume is: {capo_iqr}") print(f"The the median of Capomulin's tumor volume is: {quartiles[0.5]} ") if len(capo_outliers) != 0: print(f"The data for Capomulin contains the following outlier(s):" + str(capo_outliers)) else: print("There are no outliers in the Tumor Volume data for Capomulin.") #Creating the Box and Whiskers plot for Capomulin green_diamond = dict(markerfacecolor='g', marker='D') fig2, ax2 = plt.subplots() ax2.set_title('Final Tumor Volume for Capomulin') ax2.set_ylabel('Final Tumor Volume (mm3)') ax2.boxplot(capo_vol, flierprops=green_diamond) plt.show() #Analyzing the Quartiles and Outliers of Ramicane #Ramicane DataFrame rami_data = top4[top4['drug'].isin(['Ramicane'])] #Creating Empty lists for to loop through for plotting rami_vol = [] rami_outliers = [] # Calculate the IQR and quantitatively determine if there are any potential outliers. quartiles = rami_data['tumor_volume'].quantile([.25,.5,.75]) rami_lowerq = quartiles[.25] rami_upperq = quartiles[.75] rami_iqr = rami_upperq-rami_lowerq #Finding outliers with pandas function def outliers(df): lower_bound = rami_lowerq - (1.5*rami_iqr) upper_bound = rami_upperq + (1.5*rami_iqr) tum_vol = rami_data['tumor_volume'] for volume in tum_vol: if volume > upper_bound or volume < lower_bound: rami_outliers.append(volume) rami_vol.append(volume) else: rami_vol.append(volume) return rami_outliers outliers(rami_data) print(f"The lower quartile of Ramicane's tumor volume data is: {rami_lowerq}") print(f"The upper quartile of Ramicane's tumor volume data is: {rami_upperq}") print(f"The interquartile range of Ramicane's tumor volume data is: {rami_iqr}") print(f"The the median of Ramicane's tumor volume data is: {quartiles[0.5]} ") if len(rami_outliers) != 0: print(f"The data for Ramicane contains the following outlier(s):" + str(rami_outliers)) else: print("There are no outliers in the Tumor Volume data for Ramicane.") #Creating the Box and Whiskers plot for Ramicane green_diamond = dict(markerfacecolor='g', marker='D') fig3, ax3 = plt.subplots() ax3.set_title('Final Tumor Volume for Ramicane') ax3.set_ylabel('Final Tumor Volume (mm3)') ax3.boxplot(rami_vol, flierprops=green_diamond) plt.show() #Analyzing the Quartiles and Outliers of Infubinol #Infubinol DataFrame infu_data = top4[top4['drug'].isin(['Infubinol'])] #Creating Empty lists for to loop through for plotting infu_vol = [] infu_outliers = [] # Calculate the IQR and quantitatively determine if there are any potential outliers. quartiles = infu_data['tumor_volume'].quantile([.25,.5,.75]) infu_lowerq = quartiles[.25] infu_upperq = quartiles[.75] infu_iqr = infu_upperq-infu_lowerq #Finding outliers with pandas function def outliers(df): lower_bound = infu_lowerq - (1.5*infu_iqr) upper_bound = infu_upperq + (1.5*infu_iqr) tum_vol = infu_data['tumor_volume'] for volume in tum_vol: if volume > upper_bound or volume < lower_bound: infu_outliers.append(volume) infu_vol.append(volume) else: infu_vol.append(volume) return infu_outliers outliers(infu_data) print(f"The lower quartile of Infubinol's tumor volume data is: {infu_lowerq}") print(f"The upper quartile of Infubinol's tumor volume data is: {infu_upperq}") print(f"The interquartile range of Infubinol's tumor volume data is: {infu_iqr}") print(f"The the median of Infubinol's tumor volume data is: {quartiles[0.5]} ") if len(infu_outliers) != 0: print(f"The data for Infubinol contains the following outlier(s):" + str(infu_outliers)) else: print("There are no outliers in the Tumor Volume data for Infubinol.") #Creating the Box and Whiskers plot for Infubinol green_diamond = dict(markerfacecolor='g', marker='D') fig4, ax4 = plt.subplots() ax4.set_title('Final Tumor Volume for Infubinol') ax4.set_ylabel('Final Tumor Volume (mm3)') ax4.boxplot(infu_vol, showfliers=green_diamond) plt.show() #Analyzing the Quartiles and Outliers of Ceftamin #Ceftamin DataFrame ceft_data = top4[top4['drug'].isin(['Ceftamin'])] #Creating Empty lists for to loop through for plotting ceft_vol = [] ceft_outliers = [] # Calculate the IQR and quantitatively determine if there are any potential outliers. quartiles = ceft_data['tumor_volume'].quantile([.25,.5,.75]) ceft_lowerq = quartiles[.25] ceft_upperq = quartiles[.75] ceft_iqr = ceft_upperq-ceft_lowerq #Finding outliers with pandas function def outliers(df): lower_bound = ceft_lowerq - (1.5*ceft_iqr) upper_bound = ceft_upperq + (1.5*ceft_iqr) tum_vol = ceft_data['tumor_volume'] for volume in tum_vol: if volume > upper_bound or volume < lower_bound: ceft_outliers.append(volume) ceft_vol.append(volume) else: ceft_vol.append(volume) return ceft_outliers outliers(ceft_data) print(f"The lower quartile of Ceftamin's tumor volume data is: {ceft_lowerq}") print(f"The upper quartile of Ceftamin's tumor volume data is: {ceft_upperq}") print(f"The interquartile range of Ceftamin's tumor volume data is: {ceft_iqr}") print(f"The the median of Ceftamin's tumor volume data is: {quartiles[0.5]} ") if len(ceft_outliers) != 0: print(f"The data for Ceftamin contains the following outlier(s):" + str(ceft_outliers)) else: print("There are no outliers in the Tumor Volume data for Ceftamin.") #Creating the Box and Whiskers plot for Ceftamin green_diamond = dict(markerfacecolor='g', marker='D') fig4, ax5 = plt.subplots() ax5.set_title('Final Tumor Volume for Ceftamin') ax5.set_ylabel('Final Tumor Volume (mm3)') ax5.boxplot(ceft_vol, showfliers=green_diamond) plt.show() #Combining the box and whiskers into one plot using plotly (just to try- found it while working on the homework) trace0 = go.Box( y = capo_vol, name = "Capomulin" ) trace1 = go.Box( y = rami_vol, name = "Ramicane" ) trace2 = go.Box( y = infu_vol, name = "Infubinol" ) trace3 = go.Box( y = ceft_vol, name = "Ceftamin" ) data = [trace0, trace1, trace2, trace3] layout = go.Layout(title = "Final Tumor Volume (mm3) for the Top Four Drug Regimens") fig = go.Figure(data=data, layout=layout) pyo.plot(fig) #Combining plots using matplotlib #formatting outliers green_diamond = dict(markerfacecolor='g', marker='D') #Creating the figure fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, figsize = (5,20), sharex = True, sharey = True) fig.suptitle("Tumor Volume at Final Time Point for Drug Trials", fontsize = 16, fontweight = "bold") ax1 = plt.subplot(511) ax1.set_title('Final Tumor Volume in All Regimens') ax1.boxplot(vol_data, flierprops=green_diamond) ax2 = plt.subplot(512, sharey = ax1) ax2.set_title('Final Tumor Volume for Capomulin') ax2.boxplot(capo_vol, flierprops=green_diamond) ax3 = plt.subplot(513, sharey = ax1) ax3.set_title('Final Tumor Volume for Ramicane') ax3.set_ylabel('Final Tumor Volume (mm3)') ax3.boxplot(rami_vol, flierprops=green_diamond) ax4 = plt.subplot(514, sharey = ax1) ax4.set_title('Final Tumor Volume for Infubinol') ax4.boxplot(infu_vol, showfliers=green_diamond) ax5 = plt.subplot(515, sharey = ax1) ax5.set_title('Final Tumor Volume for Ceftamin') ax5.boxplot(ceft_vol, showfliers=green_diamond) #Save and Show plot plt.savefig('charts/tumorvol_boxplots') plt.show() ###Output _____no_output_____ ###Markdown Line and Scatter Plots ###Code # Generate a line plot of time point versus tumor volume for a mouse treated with Capomulin # Filter original data for just the Capomulin Drug Regime capomulin_mice = mouse_study.loc[(mouse_study["drug"] == "Capomulin"),:] capomulin_mouse = capomulin_mice.loc[(capomulin_mice['mouse_id'] == 's185'),:] # Set variables to hold relevant data timept = capomulin_mouse["timepoint"] tumor_vol = capomulin_mouse["tumor_volume"] # Plot the tumor volume for various mice tumor_volume_line, = plt.plot(timept, tumor_vol, marker = 'D') # Show the chart, add labels plt.xlabel('Timepoint') plt.ylabel('Tumor Volume') plt.title('Tumor Volume over Time for One Mouse on Capomulin') #Save and show figure plt.savefig('charts/capomouse_tumvol_vs_time') plt.show() # Generate a line plot of time point versus tumor volume for the mice treated with Capomulin # Filter original data for just the Capomulin Drug Regime capomulin_mice = mouse_study.loc[(mouse_study["drug"] == "Capomulin"),:] # Set variables to hold relevant data timept = capomulin_mice["timepoint"] tumor_vol = capomulin_mice["tumor_volume"] # Plot the tumor volume for various mice tumor_volume_line, = plt.plot(timept, tumor_vol, marker = 's', color = 'black') # Show the chart, add labels plt.xlabel('Timepoint') plt.ylabel('Tumor Volume') plt.title('Tumor Volume over Time for Capomulin Mice') #Save and show plot plt.savefig('charts/capomice_tumvol_vs_time') plt.show() # Generate a scatter plot of mouse weight versus average tumor volume for the Capomulin regimen # Pull values for x and y values mouse_weight = capomulin_mice.groupby(capomulin_mice["mouse_id"])["weight"].mean() tumor_volume = capomulin_mice.groupby(capomulin_mice["mouse_id"])["tumor_volume"].mean() # Create Scatter Plot with values calculated above plt.scatter(mouse_weight,tumor_volume) plt.xlabel("Weight of Mouse") plt.ylabel("Tumor Volume (mm3)") plt.title("Weight of Mouse vs. Tumor Volume on Capomulin") #Save and show plot plt.savefig('charts/weight_vs_tumvol_scatter') plt.show() ###Output _____no_output_____ ###Markdown The graph above is a scatterplot of the mice through all the timepoints during the Capomulin trial, so the mean of their weight and the tumor volume is an average for the entirety of the trial and therefore may not be representative of any specific time point. As we see in the previous line chart of weight over time in the trial, weight fluctuate drastically throughout the trial. What we can see from this graph is that there seems to be a positive correlation between weight of the mouse and tumor volume throughout the trial. Correlation and Regression ###Code # Calculate the correlation coefficient and linear regression model for mouse weight and average tumor volume for the Capomulin regimen # Pull values for x and y values mouse_weight = capomulin_mice.groupby(capomulin_mice["mouse_id"])["weight"].mean() tumor_vol = capomulin_mice.groupby(capomulin_mice["mouse_id"])["tumor_volume"].mean() # Perform a linear regression on tumor volume versus mouse weight slope, int, r, p, std_err = st.linregress(mouse_weight, tumor_vol) # Create equation of line to calculate predicted weight fit = slope * mouse_weight + int line_eq = 'y = ' +str(round(slope,2)) + 'x +' + str(round(int,2)) # Plot the linear model on top of scatter plot plt.scatter(mouse_weight,tumor_vol) plt.xlabel("Weight of Mouse") plt.ylabel("Tumor Volume") plt.title("Weight of Mouse vs. Tumor Volume on Capomulin") plt.plot(mouse_weight,fit,"-") plt.annotate(line_eq, (18,37), fontsize=15) plt.xticks(mouse_weight, rotation=90) #save and show plot plt.savefig('charts/weight_vs_tumvol_regress') plt.show() # Caculate correlation coefficient corr = round(st.pearsonr(mouse_weight,tumor_vol)[0],2) print(f'The correlation between weight and tumor value is {corr}') ###Output _____no_output_____
Data Visualization with Python/DV0101EN-Exercise-Introduction-to-Matplotlib-and-Line-Plots-py.ipynb
###Markdown Introduction to Matplotlib and Line Plots IntroductionThe aim of these labs is to introduce you to data visualization with Python as concrete and as consistent as possible. Speaking of consistency, because there is no *best* data visualization library avaiblable for Python - up to creating these labs - we have to introduce different libraries and show their benefits when we are discussing new visualization concepts. Doing so, we hope to make students well-rounded with visualization libraries and concepts so that they are able to judge and decide on the best visualitzation technique and tool for a given problem _and_ audience.Please make sure that you have completed the prerequisites for this course, namely [**Python for Data Science**](https://cognitiveclass.ai/courses/python-for-data-science/).**Note**: The majority of the plots and visualizations will be generated using data stored in *pandas* dataframes. Therefore, in this lab, we provide a brief crash course on *pandas*. However, if you are interested in learning more about the *pandas* library, detailed description and explanation of how to use it and how to clean, munge, and process data stored in a *pandas* dataframe are provided in our course [**Data Analysis with Python**](https://cognitiveclass.ai/courses/data-analysis-python/). ------------ Table of Contents1. [Exploring Datasets with *pandas*](0)1.1 [The Dataset: Immigration to Canada from 1980 to 2013](2)1.2 [*pandas* Basics](4) 1.3 [*pandas* Intermediate: Indexing and Selection](6) 2. [Visualizing Data using Matplotlib](8) 2.1 [Matplotlib: Standard Python Visualization Library](10) 3. [Line Plots](12) Exploring Datasets with *pandas* *pandas* is an essential data analysis toolkit for Python. From their [website](http://pandas.pydata.org/):>*pandas* is a Python package providing fast, flexible, and expressive data structures designed to make working with “relational” or “labeled” data both easy and intuitive. It aims to be the fundamental high-level building block for doing practical, **real world** data analysis in Python.The course heavily relies on *pandas* for data wrangling, analysis, and visualization. We encourage you to spend some time and familizare yourself with the *pandas* API Reference: http://pandas.pydata.org/pandas-docs/stable/api.html. The Dataset: Immigration to Canada from 1980 to 2013 Dataset Source: [International migration flows to and from selected countries - The 2015 revision](http://www.un.org/en/development/desa/population/migration/data/empirical2/migrationflows.shtml).The dataset contains annual data on the flows of international immigrants as recorded by the countries of destination. The data presents both inflows and outflows according to the place of birth, citizenship or place of previous / next residence both for foreigners and nationals. The current version presents data pertaining to 45 countries.In this lab, we will focus on the Canadian immigration data.For sake of simplicity, Canada's immigration data has been extracted and uploaded to one of IBM servers. You can fetch the data from [here](https://ibm.box.com/shared/static/lw190pt9zpy5bd1ptyg2aw15awomz9pu.xlsx).--- *pandas* Basics The first thing we'll do is import two key data analysis modules: *pandas* and **Numpy**. ###Code import numpy as np # useful for many scientific computing in Python import pandas as pd # primary data structure library ###Output _____no_output_____ ###Markdown Let's download and import our primary Canadian Immigration dataset using *pandas* `read_excel()` method. Normally, before we can do that, we would need to download a module which *pandas* requires to read in excel files. This module is **xlrd**. For your convenience, we have pre-installed this module, so you would not have to worry about that. Otherwise, you would need to run the following line of code to install the **xlrd** module:```!conda install -c anaconda xlrd --yes``` Now we are ready to read in our data. ###Code df_can = pd.read_excel('https://ibm.box.com/shared/static/lw190pt9zpy5bd1ptyg2aw15awomz9pu.xlsx', sheet_name='Canada by Citizenship', skiprows=range(20), skip_footer=2) print ('Data read into a pandas dataframe!') ###Output /home/jupyterlab/conda/lib/python3.6/site-packages/pandas/util/_decorators.py:177: FutureWarning: the 'skip_footer' keyword is deprecated, use 'skipfooter' instead return func(*args, **kwargs) ###Markdown Let's view the top 5 rows of the dataset using the `head()` function. ###Code df_can.head() # tip: You can specify the number of rows you'd like to see as follows: df_can.head(10) ###Output _____no_output_____ ###Markdown We can also veiw the bottom 5 rows of the dataset using the `tail()` function. ###Code df_can.tail() ###Output _____no_output_____ ###Markdown When analyzing a dataset, it's always a good idea to start by getting basic information about your dataframe. We can do this by using the `info()` method. ###Code df_can.info() ###Output <class 'pandas.core.frame.DataFrame'> RangeIndex: 195 entries, 0 to 194 Data columns (total 43 columns): Type 195 non-null object Coverage 195 non-null object OdName 195 non-null object AREA 195 non-null int64 AreaName 195 non-null object REG 195 non-null int64 RegName 195 non-null object DEV 195 non-null int64 DevName 195 non-null object 1980 195 non-null int64 1981 195 non-null int64 1982 195 non-null int64 1983 195 non-null int64 1984 195 non-null int64 1985 195 non-null int64 1986 195 non-null int64 1987 195 non-null int64 1988 195 non-null int64 1989 195 non-null int64 1990 195 non-null int64 1991 195 non-null int64 1992 195 non-null int64 1993 195 non-null int64 1994 195 non-null int64 1995 195 non-null int64 1996 195 non-null int64 1997 195 non-null int64 1998 195 non-null int64 1999 195 non-null int64 2000 195 non-null int64 2001 195 non-null int64 2002 195 non-null int64 2003 195 non-null int64 2004 195 non-null int64 2005 195 non-null int64 2006 195 non-null int64 2007 195 non-null int64 2008 195 non-null int64 2009 195 non-null int64 2010 195 non-null int64 2011 195 non-null int64 2012 195 non-null int64 2013 195 non-null int64 dtypes: int64(37), object(6) memory usage: 65.6+ KB ###Markdown To get the list of column headers we can call upon the dataframe's `.columns` parameter. ###Code df_can.columns.values ###Output _____no_output_____ ###Markdown Similarly, to get the list of indicies we use the `.index` parameter. ###Code df_can.index.values ###Output _____no_output_____ ###Markdown Note: The default type of index and columns is NOT list. ###Code print(type(df_can.columns)) print(type(df_can.index)) ###Output <class 'pandas.core.indexes.base.Index'> <class 'pandas.core.indexes.range.RangeIndex'> ###Markdown To get the index and columns as lists, we can use the `tolist()` method. ###Code df_can.columns.tolist() df_can.index.tolist() print (type(df_can.columns.tolist())) print (type(df_can.index.tolist())) ###Output <class 'list'> <class 'list'> ###Markdown To view the dimensions of the dataframe, we use the `.shape` parameter. ###Code # size of dataframe (rows, columns) df_can.shape ###Output _____no_output_____ ###Markdown Note: The main types stored in *pandas* objects are *float*, *int*, *bool*, *datetime64[ns]* and *datetime64[ns, tz] (in >= 0.17.0)*, *timedelta[ns]*, *category (in >= 0.15.0)*, and *object* (string). In addition these dtypes have item sizes, e.g. int64 and int32. Let's clean the data set to remove a few unnecessary columns. We can use *pandas* `drop()` method as follows: ###Code # in pandas axis=0 represents rows (default) and axis=1 represents columns. df_can.drop(['AREA','REG','DEV','Type','Coverage'], axis=1, inplace=True) df_can.head(2) ###Output _____no_output_____ ###Markdown Let's rename the columns so that they make sense. We can use `rename()` method by passing in a dictionary of old and new names as follows: ###Code df_can.rename(columns={'OdName':'Country', 'AreaName':'Continent', 'RegName':'Region'}, inplace=True) df_can.columns ###Output _____no_output_____ ###Markdown We will also add a 'Total' column that sums up the total immigrants by country over the entire period 1980 - 2013, as follows: ###Code df_can['Total'] = df_can.sum(axis=1) ###Output _____no_output_____ ###Markdown We can check to see how many null objects we have in the dataset as follows: ###Code df_can.isnull().sum() ###Output _____no_output_____ ###Markdown Finally, let's view a quick summary of each column in our dataframe using the `describe()` method. ###Code df_can.describe() ###Output _____no_output_____ ###Markdown --- *pandas* Intermediate: Indexing and Selection (slicing) Select Column**There are two ways to filter on a column name:**Method 1: Quick and easy, but only works if the column name does NOT have spaces or special characters.```python df.column_name (returns series)```Method 2: More robust, and can filter on multiple columns.```python df['column'] (returns series)``````python df[['column 1', 'column 2']] (returns dataframe)```--- Example: Let's try filtering on the list of countries ('Country'). ###Code df_can.Country # returns a series ###Output _____no_output_____ ###Markdown Let's try filtering on the list of countries ('OdName') and the data for years: 1980 - 1985. ###Code df_can[['Country', 1980, 1981, 1982, 1983, 1984, 1985]] # returns a dataframe # notice that 'Country' is string, and the years are integers. # for the sake of consistency, we will convert all column names to string later on. ###Output _____no_output_____ ###Markdown Select RowThere are main 3 ways to select rows:```python df.loc[label] filters by the labels of the index/column df.iloc[index] filters by the positions of the index/column``` Before we proceed, notice that the defaul index of the dataset is a numeric range from 0 to 194. This makes it very difficult to do a query by a specific country. For example to search for data on Japan, we need to know the corressponding index value.This can be fixed very easily by setting the 'Country' column as the index using `set_index()` method. ###Code df_can.set_index('Country', inplace=True) # tip: The opposite of set is reset. So to reset the index, we can use df_can.reset_index() df_can.head(3) # optional: to remove the name of the index df_can.index.name = None ###Output _____no_output_____ ###Markdown Example: Let's view the number of immigrants from Japan (row 87) for the following scenarios: 1. The full row data (all columns) 2. For year 2013 3. For years 1980 to 1985 ###Code # 1. the full row data (all columns) print(df_can.loc['Japan']) # alternate methods print(df_can.iloc[87]) print(df_can[df_can.index == 'Japan'].T.squeeze()) # 2. for year 2013 print(df_can.loc['Japan', 2013]) # alternate method print(df_can.iloc[87, 36]) # year 2013 is the last column, with a positional index of 36 # 3. for years 1980 to 1985 print(df_can.loc['Japan', [1980, 1981, 1982, 1983, 1984, 1984]]) print(df_can.iloc[87, [3, 4, 5, 6, 7, 8]]) ###Output 1980 701 1981 756 1982 598 1983 309 1984 246 1984 246 Name: Japan, dtype: object 1980 701 1981 756 1982 598 1983 309 1984 246 1985 198 Name: Japan, dtype: object ###Markdown Column names that are integers (such as the years) might introduce some confusion. For example, when we are referencing the year 2013, one might confuse that when the 2013th positional index. To avoid this ambuigity, let's convert the column names into strings: '1980' to '2013'. ###Code df_can.columns = list(map(str, df_can.columns)) # [print (type(x)) for x in df_can.columns.values] #<-- uncomment to check type of column headers ###Output _____no_output_____ ###Markdown Since we converted the years to string, let's declare a variable that will allow us to easily call upon the full range of years: ###Code # useful for plotting later on years = list(map(str, range(1980, 2014))) years ###Output _____no_output_____ ###Markdown Filtering based on a criteriaTo filter the dataframe based on a condition, we simply pass the condition as a boolean vector. For example, Let's filter the dataframe to show the data on Asian countries (AreaName = Asia). ###Code # 1. create the condition boolean series condition = df_can['Continent'] == 'Asia' print (condition) # 2. pass this condition into the dataFrame df_can[condition] # we can pass mutliple criteria in the same line. # let's filter for AreaNAme = Asia and RegName = Southern Asia df_can[(df_can['Continent']=='Asia') & (df_can['Region']=='Southern Asia')] # note: When using 'and' and 'or' operators, pandas requires we use '&' and '|' instead of 'and' and 'or' # don't forget to enclose the two conditions in parentheses ###Output _____no_output_____ ###Markdown Before we proceed: let's review the changes we have made to our dataframe. ###Code print ('data dimensions:', df_can.shape) print(df_can.columns) df_can.head(2) ###Output data dimensions: (195, 38) Index(['Continent', 'Region', 'DevName', '1980', '1981', '1982', '1983', '1984', '1985', '1986', '1987', '1988', '1989', '1990', '1991', '1992', '1993', '1994', '1995', '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006', '2007', '2008', '2009', '2010', '2011', '2012', '2013', 'Total'], dtype='object') ###Markdown --- Visualizing Data using Matplotlib Matplotlib: Standard Python Visualization LibraryThe primary plotting library we will explore in the course is [Matplotlib](http://matplotlib.org/). As mentioned on their website: >Matplotlib is a Python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. Matplotlib can be used in Python scripts, the Python and IPython shell, the jupyter notebook, web application servers, and four graphical user interface toolkits.If you are aspiring to create impactful visualization with python, Matplotlib is an essential tool to have at your disposal. Matplotlib.PyplotOne of the core aspects of Matplotlib is `matplotlib.pyplot`. It is Matplotlib's scripting layer which we studied in details in the videos about Matplotlib. Recall that it is a collection of command style functions that make Matplotlib work like MATLAB. Each `pyplot` function makes some change to a figure: e.g., creates a figure, creates a plotting area in a figure, plots some lines in a plotting area, decorates the plot with labels, etc. In this lab, we will work with the scripting layer to learn how to generate line plots. In future labs, we will get to work with the Artist layer as well to experiment first hand how it differs from the scripting layer. Let's start by importing `Matplotlib` and `Matplotlib.pyplot` as follows: ###Code # we are using the inline backend %matplotlib inline import matplotlib as mpl import matplotlib.pyplot as plt ###Output _____no_output_____ ###Markdown *optional: check if Matplotlib is loaded. ###Code print ('Matplotlib version: ', mpl.__version__) # >= 2.0.0 ###Output Matplotlib version: 2.2.2 ###Markdown *optional: apply a style to Matplotlib. ###Code print(plt.style.available) mpl.style.use(['ggplot']) # optional: for ggplot-like style ###Output ['Solarize_Light2', '_classic_test', 'bmh', 'classic', 'dark_background', 'fast', 'fivethirtyeight', 'ggplot', 'grayscale', 'seaborn-bright', 'seaborn-colorblind', 'seaborn-dark-palette', 'seaborn-dark', 'seaborn-darkgrid', 'seaborn-deep', 'seaborn-muted', 'seaborn-notebook', 'seaborn-paper', 'seaborn-pastel', 'seaborn-poster', 'seaborn-talk', 'seaborn-ticks', 'seaborn-white', 'seaborn-whitegrid', 'seaborn', 'tableau-colorblind10'] ###Markdown Plotting in *pandas*Fortunately, pandas has a built-in implementation of Matplotlib that we can use. Plotting in *pandas* is as simple as appending a `.plot()` method to a series or dataframe.Documentation:- [Plotting with Series](http://pandas.pydata.org/pandas-docs/stable/api.htmlplotting)- [Plotting with Dataframes](http://pandas.pydata.org/pandas-docs/stable/api.htmlapi-dataframe-plotting) Line Pots (Series/Dataframe) **What is a line plot and why use it?**A line chart or line plot is a type of plot which displays information as a series of data points called 'markers' connected by straight line segments. It is a basic type of chart common in many fields.Use line plot when you have a continuous data set. These are best suited for trend-based visualizations of data over a period of time. **Let's start with a case study:**In 2010, Haiti suffered a catastrophic magnitude 7.0 earthquake. The quake caused widespread devastation and loss of life and aout three million people were affected by this natural disaster. As part of Canada's humanitarian effort, the Government of Canada stepped up its effort in accepting refugees from Haiti. We can quickly visualize this effort using a `Line` plot:**Question:** Plot a line graph of immigration from Haiti using `df.plot()`. First, we will extract the data series for Haiti. ###Code haiti = df_can.loc['Haiti', years] # passing in years 1980 - 2013 to exclude the 'total' column haiti.head() ###Output _____no_output_____ ###Markdown Next, we will plot a line plot by appending `.plot()` to the `haiti` dataframe. ###Code haiti.plot() ###Output _____no_output_____ ###Markdown *pandas* automatically populated the x-axis with the index values (years), and the y-axis with the column values (population). However, notice how the years were not displayed because they are of type *string*. Therefore, let's change the type of the index values to *integer* for plotting.Also, let's label the x and y axis using `plt.title()`, `plt.ylabel()`, and `plt.xlabel()` as follows: ###Code haiti.index = haiti.index.map(int) # let's change the index values of Haiti to type integer for plotting haiti.plot(kind='line') plt.title('Immigration from Haiti') plt.ylabel('Number of immigrants') plt.xlabel('Years') plt.show() # need this line to show the updates made to the figure ###Output _____no_output_____ ###Markdown We can clearly notice how number of immigrants from Haiti spiked up from 2010 as Canada stepped up its efforts to accept refugees from Haiti. Let's annotate this spike in the plot by using the `plt.text()` method. ###Code haiti.plot(kind='line') plt.title('Immigration from Haiti') plt.ylabel('Number of Immigrants') plt.xlabel('Years') # annotate the 2010 Earthquake. # syntax: plt.text(x, y, label) plt.text(2000, 6000, '2010 Earthquake') # see note below plt.show() ###Output _____no_output_____ ###Markdown With just a few lines of code, you were able to quickly identify and visualize the spike in immigration!Quick note on x and y values in `plt.text(x, y, label)`: Since the x-axis (years) is type 'integer', we specified x as a year. The y axis (number of immigrants) is type 'integer', so we can just specify the value y = 6000. ```python plt.text(2000, 6000, '2010 Earthquake') years stored as type int``` If the years were stored as type 'string', we would need to specify x as the index position of the year. Eg 20th index is year 2000 since it is the 20th year with a base year of 1980.```python plt.text(20, 6000, '2010 Earthquake') years stored as type int``` We will cover advanced annotation methods in later modules. We can easily add more countries to line plot to make meaningful comparisons immigration from different countries. **Question:** Let's compare the number of immigrants from India and China from 1980 to 2013. Step 1: Get the data set for China and India, and display dataframe. ###Code ### type your answer here df_CI = df_can.loc[['India', 'China'], years] df_CI.head() ###Output _____no_output_____ ###Markdown Double-click __here__ for the solution.<!-- The correct answer is:df_CI = df_can.loc[['India', 'China'], years]df_CI.head()--> Step 2: Plot graph. We will explicitly specify line plot by passing in `kind` parameter to `plot()`. ###Code ### type your answer here df_CI.plot(kind='line') ###Output _____no_output_____ ###Markdown Double-click __here__ for the solution.<!-- The correct answer is:df_CI.plot(kind='line')--> That doesn't look right...Recall that *pandas* plots the indices on the x-axis and the columns as individual lines on the y-axis. Since `df_CI` is a dataframe with the `country` as the index and `years` as the columns, we must first transpose the dataframe using `transpose()` method to swap the row and columns. ###Code df_CI = df_CI.transpose() df_CI.head() ###Output _____no_output_____ ###Markdown *pandas* will auomatically graph the two countries on the same graph. Go ahead and plot the new transposed dataframe. Make sure to add a title to the plot and label the axes. ###Code ### type your answer here df_CI.index = df_CI.index.map(int) df_CI.plot(kind='line') plt.title('Immigrants from India and China') plt.xlabel('Years') plt.ylabel('Number of Immigrants') plt.show() ###Output _____no_output_____ ###Markdown Double-click __here__ for the solution.<!-- The correct answer is:df_CI.index = df_CI.index.map(int) let's change the index values of df_CI to type integer for plottingdf_CI.plot(kind='line')--><!--plt.title('Immigrants from China and India')plt.ylabel('Number of Immigrants')plt.xlabel('Years')--><!--plt.show()--> From the above plot, we can observe that the China and India have very similar immigration trends through the years. *Note*: How come we didn't need to transpose Haiti's dataframe before plotting (like we did for df_CI)?That's because `haiti` is a series as opposed to a dataframe, and has the years as its indices as shown below. ```pythonprint(type(haiti))print(haiti.head(5))```>class 'pandas.core.series.Series' >1980 1666 >1981 3692 >1982 3498 >1983 2860 >1984 1418 >Name: Haiti, dtype: int64 Line plot is a handy tool to display several dependent variables against one independent variable. However, it is recommended that no more than 5-10 lines on a single graph; any more than that and it becomes difficult to interpret. **Question:** Compare the trend of top 5 countries that contributed the most to immigration to Canada. ###Code ### type your answer here df_can.sort_values(by='Total', ascending=False, axis=0, inplace=True) df_top5 = df_can.head(5) df_top5 = df_top5[years].transpose() print(df_top5) df_top5.index = df_top5.index.map(int) df_top5.plot(kind='line', figsize=(14, 8)) plt.title('Immigration Trend of Top 5 Countries') plt.xlabel('Years') plt.ylabel('Number of Immigrants') plt.show() ###Output _____no_output_____
MServajean/TD4/Spark_-_Stream_of_data_correction.ipynb
###Markdown Importing spark ###Code # import findspark # findspark.init() import pyspark from pyspark.sql import SparkSession spark = SparkSession.builder.appName("Python Spark").getOrCreate() sc = spark.sparkContext ###Output _____no_output_____ ###Markdown Preparing the data ###Code df_transactions = spark.read.option("header", True)\ .option("delimiter", "|")\ .option("delimiter", ",")\ .option("inferSchema", "true")\ .csv('data/train.csv')\ .withColumnRenamed('default_payment_next_month', 'label') df_transactions.printSchema() train, test = df_transactions.randomSplit([0.8, 0.2]) ###Output _____no_output_____ ###Markdown Preparing the model ###Code from pyspark.ml import Pipeline from pyspark.ml.feature import VectorAssembler from pyspark.ml.classification import LogisticRegression assembler = VectorAssembler( inputCols=["MARRIAGE", "EDUCATION", "PAY_0", "PAY_2", "PAY_3"], outputCol="features" ) lr = LogisticRegression(maxIter=10, regParam=10.0, elasticNetParam=0.0) pipeline = Pipeline(stages=[assembler, lr]) ###Output _____no_output_____ ###Markdown Fitting the model ###Code model = pipeline.fit(train) ###Output _____no_output_____ ###Markdown Evaluation of the model ###Code predictions = model.transform(test) predictions.printSchema() from pyspark.ml.evaluation import BinaryClassificationEvaluator evaluator_roc = BinaryClassificationEvaluator( labelCol='label', rawPredictionCol='rawPrediction', metricName='areaUnderROC' ) print('Area under ROC = %s' % evaluator_roc.evaluate(predictions)) ###Output Area under ROC = 0.6825956971417326 ###Markdown Streaming data The stream will be produced by ```generate_transactions.py``` ###Code from pyspark.streaming import StreamingContext ssc = StreamingContext(sc, 1) def process(time, rdd): print("========= %s =========" % str(time)) try: # Convert RDD[String] to DataFrame rdd_proper = rdd.map(lambda line: line.split(',')) df_stream = spark.createDataFrame(rdd_proper) # changing schema for c, i in zip(df_stream.columns, train.schema): df_stream = df_stream.withColumn(i.name, df_stream[c].cast(i.dataType)) if df_stream.count() > 0: predictions = model.transform(df_stream) print( 'Area under ROC = %s (with %ld elements)' % (evaluator_roc.evaluate(predictions), df_stream.count()) ) except Exception as e: print(e) stream = ssc.textFileStream('data/output/') stream.foreachRDD(process) ssc.start() # ssc.awaitTermination() # stop stream ssc.stop(True, True) ###Output _____no_output_____
drl-portfolio-optimization.ipynb
###Markdown DRL Portfolio Optimization AcknowledgementsThis workbook is the culmination of three separate half credit independent studies by the author [Daniel Fudge](https://www.linkedin.com/in/daniel-fudge) with [Professor Yelena Larkin](https://www.linkedin.com/in/yelena-larkin-6b7b361b/) as part of a concurrent Master of Business Administration (MBA) and a [Diploma in Financial Engineering](https://schulich.yorku.ca/programs/fnen/) from the [Schulich School of Business](https://schulich.yorku.ca/). I wanted to thank Schulich and especially Professor Larkin for giving me the freedom to explorer the intersection of Machine Learning and Finance. I'd like to also mention the excellent training I recieved from [A Cloud Guru](https://acloud.guru/learn/aws-certified-machine-learning-specialty) to prepare for this project. This notebook takes much of the design and low level code from the AWS sample portfolio management [Notebook](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/reinforcement_learning/rl_portfolio_management_coach_customEnv), which inturn is based on Jiang, Zhengyao, Dixing Xu, and Jinjun Liang. "A deep reinforcement learning framework for the financial portfolio management problem." arXiv preprint arXiv:1706.10059 (2017). As detailed below, this notebook relies on the [RL Coach](https://github.com/NervanaSystems/coachbatch-reinforcement-learning) from Intel AI Labs, Apache [MXNet](https://mxnet.apache.org/) and OpenAI [Gym](https://gym.openai.com/). All of which are amazing projects that I highly recommend investigating. IntroductionNow that we have the signals `signals.pkl` and prices `stock-data-clean.pkl` processed we can build the Reinforcement Learning algorithm. The signals will be used to define the state of the market environment, called `observations` in the Gym documentation and `state` in other locations. The prices will be used to generate the `rewards`. For a refresher on DRL I recommend looking through [report2](docs/report2.pdf) in this repo. The basic RL feed back loop is shown below. ![RL](docs/rl.png "Reinforcement Learning Loop")Reinforcement Learning feedback loop. Image source: https://i.stack.imgur.com/eoeSq.png Action SpaceThe `action` space is simply vector containing the weights of the stocks in the portfolio. Inside the environment these weights are limited to (0, 1) and an addition weight is added for the amount of cash in the portfolio. The cash weight is simply one minus the sum of the other weights and also limited to (0, 1). The last step is to normalize these weight so the sum is equal to 1.0. State (or Observation)The `state` is simply the signals we compiled in the previous data preparation [notebook](docs/data-preparation-no-memory.ipynb) including a time embbeding called the `window_length` within the code. Instead of using the LSTM discussed previously, we are using a short Convolutional Neural Net (CNN) to capture some historical information from the data within the `agent`. AgentFor the agent we are using the [RL Coach](https://github.com/NervanaSystems/coachbatch-reinforcement-learning) from Intel AI Labs that is integrated into AWS [Sagemaker](https://docs.aws.amazon.com/sagemaker/latest/dg/reinforcement-learning.htmlsagemaker-rl). As you can see below there are a large number of RL algorithms to choose from. In [report2](docs/report2.pdf) we discussed serval of these and focused on the Deep Deterministic Policy Gradient (DDPG) Actor-Critic method however for this test we are trying the Proximal Policy Optimization (PPO) algorithm that is explained nicely by Jonathan Hui [here](https://medium.com/@jonathan_hui/rl-proximal-policy-optimization-ppo-explained-77f014ec3f12) and the original paper by Schulman et al. [here](https://arxiv.org/pdf/1707.06347.pdf). Remember that the goal of the agent is to learn a policy that maximizes the sum of discounted rewards, which in our case will result in the maximization of the portfolio value.![Coach](docs/rl-coach.png)RL Coach AlgorithmsImafe Source: https://github.com/NervanaSystems/coachbatch-reinforcement-learning Tweaks to AgentIf you are playing with the number of signals you may have to change the input to the Agent. Unfortunately one of the disadvantages of using pre-built frameworks is the extra overhead and the difficulity finding the little details you need to tweak. Here we have to define input, which for us is a 2D CNN or Conv2D as a RL Coach [input embedder](https://nervanasystems.github.io/coach/design/network.html) but it is actually passed to the Conv2D within Apache [MXNet]. The RL Coach [code](https://github.com/NervanaSystems/coach/blob/master/rl_coach/architectures/layers.py) that passes the arguments to the MXNet Conv2D [code](https://beta.mxnet.io/api/gluon/_autogen/mxnet.gluon.nn.Conv2D.html) only accepts the 3 arguments and the MXNet infers the rest. This lack of control makes setting up the problem a little tricky. Also for time series data the MXNet [Conv1D](https://beta.mxnet.io/api/gluon/_autogen/mxnet.gluon.nn.Conv1D.html) would be more appropriate but RL coach doesn't give us the flexibility. The interface to RL Coach is defined in `preset-portfolio-management-clippedppo.py` shown below. The line you may want to tweak is under "Agent" and contains the Conv2D argument. This needs to coorespond to the observation space definition and how the observation is pulled from the signals in the `portfolio_env.py` file shown below as well. Both of these are in the `src` folder. ###Code !pygmentize src/preset-portfolio-management-clippedppo.py ###Output from rl_coach.agents.clipped_ppo_agent import ClippedPPOAgentParameters from rl_coach.architectures.layers import Dense, Conv2d from rl_coach.base_parameters import VisualizationParameters, PresetValidationParameters from rl_coach.base_parameters import MiddlewareScheme, DistributedCoachSynchronizationType from rl_coach.core_types import TrainingSteps, EnvironmentEpisodes, EnvironmentSteps, RunPhase from rl_coach.environments.gym_environment import GymVectorEnvironment, ObservationSpaceType from rl_coach.exploration_policies.e_greedy import EGreedyParameters from rl_coach.graph_managers.basic_rl_graph_manager import BasicRLGraphManager from rl_coach.graph_managers.graph_manager import ScheduleParameters from rl_coach.schedules import LinearSchedule #################### # Graph Scheduling # #################### schedule_params = ScheduleParameters() schedule_params.improve_steps = TrainingSteps(20000) schedule_params.steps_between_evaluation_periods = EnvironmentSteps(2048) schedule_params.evaluation_steps = EnvironmentEpisodes(5) schedule_params.heatup_steps = EnvironmentSteps(0) ######### # Agent # ######### agent_params = ClippedPPOAgentParameters() # Input Embedder with no CNN #agent_params.network_wrappers['main'].input_embedders_parameters['observation'].scheme = [Dense(71)] #agent_params.network_wrappers['main'].input_embedders_parameters['observation'].activation_function = 'tanh' #agent_params.network_wrappers['main'].middleware_parameters.scheme = [Dense(128)] #agent_params.network_wrappers['main'].middleware_parameters.activation_function = 'tanh' # Input Embedder used in sample notebook agent_params.network_wrappers['main'].input_embedders_parameters['observation'].scheme = [Conv2d(32, [3, 1], 1)] agent_params.network_wrappers['main'].middleware_parameters.scheme = MiddlewareScheme.Empty agent_params.network_wrappers['main'].learning_rate = 0.0001 agent_params.network_wrappers['main'].batch_size = 64 agent_params.algorithm.clipping_decay_schedule = LinearSchedule(1.0, 0, 150000) agent_params.algorithm.discount = 0.99 agent_params.algorithm.num_steps_between_copying_online_weights_to_target = EnvironmentSteps(2048) # Distributed Coach synchronization type. agent_params.algorithm.distributed_coach_synchronization_type = DistributedCoachSynchronizationType.SYNC agent_params.exploration = EGreedyParameters() agent_params.exploration.epsilon_schedule = LinearSchedule(1.0, 0.01, 10000) ############### # Environment # ############### env_params = GymVectorEnvironment(level='portfolio_env:PortfolioEnv') env_params.__dict__['observation_space_type'] = ObservationSpaceType.Tensor ######## # Test # ######## preset_validation_params = PresetValidationParameters() preset_validation_params.test = True graph_manager = BasicRLGraphManager(agent_params=agent_params, env_params=env_params, schedule_params=schedule_params, vis_params=VisualizationParameters(), preset_validation_params=preset_validation_params) ###Markdown EnvironmentThis leaves us with the environment to generate. Here we build a custom finacial market environment (or simulator) based on the signals and prices we compiled previously on top of the OpenAI [Gym](https://gym.openai.com/), which is also integrated into AWS [Sagemaker](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-rl-environments.htmlsagemaker-rl-environments-gym). This takes care of the low level integration allows us to focus on the features of the environment specific to portfolio optimization. During each training epoch, the trainer randomly selects a date to start. It then steps through each day in the epoch and following these high level operations.1. Initialze the state from the signals with the randomly selected start date and sets the portfolio to $1 of cash.1. Pass the state to the agent who generates an action, which is a new set of desired portfolio weights.1. Pass the new weigths (action) to the environment who calculates: * The new portfolio value based on changes in the prices, weights and transaction costs. * The reward based on the previous weights and the change in prices. * The new state, which is simply pulled from the signals dataset.1. Pass the new reward and state to the agent, who must then learn to make a better action. Custom Portfolio EnvironmentThe code below implements the custom financial market environment that the agent must trade in. ###Code !pygmentize src/portfolio_env.py ###Output """ Modified from https://github.com/awslabs/amazon-sagemaker-examples """ import gym import gym.spaces import os import numpy as np import pandas as pd EPS = 1e-8 class PortfolioEnv(gym.Env): """ This class creates the financial market environment that the Agent interact with.   It extends the OpenAI Gym environment https://gym.openai.com/.   More information of how it is integrated into AWS is found here  https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-rl-environments.html#sagemaker-rl-environments-gym   The observations include a history of the signals with the given `window_length` ending at the current date.   Args:  steps (int): Steps or days in an episode.  trading_cost (float): Cost of trade as a fraction.  window_length (int): How many past observations to return.  start_date_index (int | None): The date index in the signals and price arrays.   Attributes:  action_space (gym.spaces.Box): [n_tickers] The portfolio weighting not including cash.  dates (np.array of np.datetime64): [n_days] Dates for the signals and price history arrays.  info_list (list): List of info dictionaries for each step.  n_signals (int): Number of signals in each observation.  n_tickers (int): Number of tickers in the price history.  observation_space (gym.spaces.Box) [self.n_signals, window_length] The signals with a window_length history.  portfolio_value (float): The portfolio value, starting with $1 in cash.  gain (np.array): [n_days, n_tickers, gain] The relative price vector; today's / yesterday's price.  signals (np.array): [n_signals, n_days, 1] Signals that define the observable environment.  start_date_index (int): The date index in the signals and price arrays.  step_number (int): The step number of the episode.  steps (int): Steps or days in an episode.  test (bool): Indicates if this is a test or training session.  test_length (int): Trading days reserved for testing.  tickers (list of str): The stock tickers.  trading_cost (float): Cost of trade as a fraction.  window_length (int): How many past observations to return.  """ def __init__(self, steps=506, trading_cost=0.0025, window_length=5, start_date_index=None): """An environment for financial portfolio management.""" # Initialize some local parameters self.csv = '/opt/ml/output/data/portfolio-management.csv' self.info_list = list() self.portfolio_value = 1.0 self.start_date_index = start_date_index self.step_number = 0 self.steps = steps self.test_length = 506 self.trading_cost = trading_cost # Save some arguments as attributes self.window_length = window_length # Determine if this is a test or training session and limit the start_date_index accordingly self.test = False with open(os.path.join(os.path.dirname(__file__), 'session-type.txt')) as f: tmp = f.read().lower() if tmp.startswith('test'): self.test = True elif tmp.startswith('train'): self.test = False else: raise ValueError('Session type not defined!!!') # Read the stock data and convert to the relative price vector (gain) # Note the raw prices have an extra day vs the signals to calculate gain raw_prices = pd.read_csv(os.path.join(os.path.dirname(__file__), 'prices.csv'),index_col=0, parse_dates=True) self.tickers = raw_prices.columns.tolist() self.gain = np.hstack((np.ones((raw_prices.shape[0]-1, 1)), raw_prices.values[1:] / raw_prices.values[:-1])) self.dates = raw_prices.index.values[1:] self.n_dates = self.dates.shape[0] self.n_tickers = len(self.tickers) self.weights = np.insert(np.zeros(self.n_tickers), 0, 1.0) # Read the signals self.signals = pd.read_csv(os.path.join(os.path.dirname(__file__), 'signals.csv'), index_col=0, parse_dates=True).T.values[:, :, np.newaxis] self.n_signals = self.signals.shape[0] # Define the action space as the portfolio weights where wn are [0, 1] for each asset not including cash self.action_space = gym.spaces.Box(low=0, high=1, shape=(self.n_tickers,), dtype=np.float32) # Define the observation space, which are the signals self.observation_space = gym.spaces.Box(low=-1, high=1, shape=(self.n_signals, self.window_length, 1), dtype=np.float32) # Rest the environment self.reset() # ----------------------------------------------------------------------------------- def step(self, action): """Step the environment.   See https://gym.openai.com/docs/#observations for detailed description of return values.   Args:  action (np.array): The desired portfolio weights [w0...].   Returns:  np.array: [n_signals, window_length, 1] The observation of the environment (state)  float: The reward received from the previous action.  bool: Indicates if the simulation is complete.  dict: Debugging information.  """ self.step_number += 1 # Force the new weights (w1) to (0.0, 1.0) and sum weights = 1, note 1st weight is cash. w1 = np.clip(action, a_min=0, a_max=1) w1 = np.insert(w1, 0, np.clip(1 - w1.sum(), a_min=0, a_max=1)) w1 = w1 / w1.sum() # Calculate the reward; Numbered equations are from https://arxiv.org/abs/1706.10059 t = self.start_date_index + self.step_number y1 = self.gain[t] w0 = self.weights p0 = self.portfolio_value dw1 = (y1 * w0) / (np.dot(y1, w0) + EPS) # (eq7) weights evolve into mu1 = self.trading_cost * (np.abs(dw1 - w1)).sum() # (eq16) cost to change portfolio p1 = p0 * (1 - mu1) * np.dot(y1, w1) # (eq11) final portfolio value p1 = np.clip(p1, 0, np.inf) # Limit portfolio to zero (busted) rho1 = p1 / p0 - 1 # rate of returns reward = np.log((p1 + EPS) / (p0 + EPS)) # log rate of return # Save weights and portfolio value for next iteration self.weights = w1 self.portfolio_value = p1 # Observe the new environment (state) t0 = t - self.window_length + 1 observation = self.signals[:, t0:t+1, :] # Save some information for debugging and plotting at the end r = y1.mean() if self.step_number == 1: market_value = r else: market_value = self.info_list[-1]["market_value"] * r info = {"reward": reward, "log_return": reward, "portfolio_value": p1, "return": r, "rate_of_return": rho1, "weights_mean": w1.mean(), "weights_std": w1.std(), "cost": mu1, 'date': self.dates[t], 'steps': self.step_number, "market_value": market_value} self.info_list.append(info) # Check if finished and write to file done = False if (self.step_number >= self.steps) or (p1 <= 0): done = True pd.DataFrame(self.info_list).sort_values(by=['date']).to_csv(self.csv) return observation, reward, done, info def reset(self): """Reset the environment to the initial state.   Ref:  https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-rl-environments.html#sagemaker-rl-environments-gym  """ self.info_list = list() self.weights = np.insert(np.zeros(self.n_tickers), 0, 1.0) self.portfolio_value = 1.0 self.step_number = 0 if self.test: self.start_date_index = self.n_dates - self.test_length elif self.start_date_index is None: self.start_date_index = np.random.random_integers(self.window_length - 1, self.n_dates - self.test_length - self.steps) else: # The start index must >= the window length to avoid a negative index or data leakage self.start_date_index = max(self.start_date_index, self.window_length - 1) # The start index <= n_dates - test length - the steps in the episode to avoid reading test data self.start_date_index = min(self.start_date_index, self.n_dates - self.test_length - self.steps) t = self.start_date_index + self.step_number t0 = t - self.window_length + 1 observation = self.signals[:, t0:t+1, :] return observation ###Markdown Setup Roles and permissionsTo get started, we'll import the Python libraries we need, set up the environment with a few prerequisites for permissions and configurations. ###Code import boto3 import glob from IPython.display import HTML import matplotlib.pyplot as plt import numpy as np import os import pandas as pd import re import sagemaker from sagemaker.rl import RLEstimator, RLToolkit, RLFramework from src.misc import get_execution_role, wait_for_s3_object import sys import subprocess import time from time import gmtime, strftime sys.path.append("common") %matplotlib inline ###Output _____no_output_____ ###Markdown Setup S3 bucketsSet up the linkage and authentication to the S3 bucket that you want to use for checkpoint and the metadata. ###Code sage_session = sagemaker.session.Session() s3_bucket = sage_session.default_bucket() s3_output_path = 's3://{}/'.format(s3_bucket) checkpoint_path = s3_output_path[:-1] + '/checkpoints' print("Checkpoint s3 path: {}".format(checkpoint_path)) ###Output Checkpoint s3 path: s3://sagemaker-us-east-1-031118886020/checkpoints ###Markdown Create an IAM roleGet the execution IAM role that allows this notebook to connect to the training and evaluation instances. ###Code role = sagemaker.get_execution_role() print("Using IAM role arn: {}".format(role)) ###Output Using IAM role arn: arn:aws:iam::031118886020:role/sagemaker ###Markdown Train the RL model using the Python SDK Script mode1. Specify the source directory where the environment, presets and training code is uploaded, `src`.2. Specify the `entry_point` as the training code, 3. Specify the choice of RL `toolkit` and framework. This automatically resolves to the ECR path for the RL Container. 4. Define the training parameters such as the instance count, job name, S3 path for output and job name. 5. Specify the hyperparameters for the RL agent algorithm. The `RLCOACH_PRESET` can be used to specify the RL agent algorithm you want to use. 6. [Optional] Choose the metrics that you are interested in capturing in your logs. These can also be visualized in CloudWatch and SageMaker Notebooks. The metrics are defined using regular expression matching. Price reference - 60,000 steps & no middleware networkHere are some price data for reference. Obviously these values will change as you change the hyperparameters and model architecture. Please check the pricing [list](https://aws.amazon.com/sagemaker/pricing/) for the latest pricing and instance types.- **ml.c4.xlarge:** $423s = 7.1 min = 0.118 hr \rightarrow \$0.03 = 0.118 hr \cdot 0.279 \frac{\$}{hr} $ - **ml.c4.2xlarge:** $371s = 6.2 min = 0.103 hr \rightarrow \$0.06 = 0.103 hr \cdot 0.557 \frac{\$}{hr} $ - **ml.c4.4xlarge:** $380s = 6.3 min = 0.106 hr \rightarrow \$0.12 = 0.106 hr \cdot 1.114 \frac{\$}{hr} $ - **ml.c4.8xlarge:** $390s = 6.5 min = 0.108 hr \rightarrow \$0.24 = 0.108 hr \cdot 2.227 \frac{\$}{hr} $ - **ml.m4.4xlarge:** $414s = 6.9 min = 0.115 hr \rightarrow \$0.13 = 0.115 hr \cdot 1.12 \frac{\$}{hr} $ - **ml.p3.2xlarge:** $558s = 9.3 min = 0.155 hr \rightarrow \$0.66 = 0.155 hr \cdot 4.284 \frac{\$}{hr}$- **ml.p2.xlarge:** $713s = 11.9 min = 0.198 hr \rightarrow \$0.25 = 0.198 hr \cdot 1.26 \frac{\$}{hr}$ ###Code instance_type = "ml.c4.2xlarge" # First define the Reinforcement Learning Estimator train_estimator = RLEstimator(source_dir='src', entry_point="train-coach.py", dependencies=["common/sagemaker_rl"], toolkit=RLToolkit.COACH, toolkit_version='0.11.0', framework=RLFramework.MXNET, role=role, train_instance_count=1, train_instance_type=instance_type, output_path=s3_output_path, hyperparameters = { "RLCOACH_PRESET" : "preset-portfolio-management-clippedppo", "rl.agent_params.algorithm.discount": 0.9, "rl.evaluation_steps:EnvironmentEpisodes": 5, "training_epochs": 10, "improve_steps":100000}) # Perform the training train_estimator.fit() # Bring the training output back to the Sagemaker instance train_job_name = train_estimator._current_job_name print("\nJob name: {}\n".format(train_job_name)) output_tar_key = "{}/output/output.tar.gz".format(train_job_name) intermediate_folder_key = "{}/output/intermediate/".format(train_job_name) intermediate_url = "s3://{}/{}".format(s3_bucket, intermediate_folder_key) tmp_dir = "/tmp/{}".format(train_job_name) local_checkpoint_path = tmp_dir + '/checkpoint' os.system("mkdir {}".format(tmp_dir)) wait_for_s3_object(s3_bucket, output_tar_key, tmp_dir) os.system("tar -xvzf {}/output.tar.gz -C {}".format(tmp_dir, tmp_dir)) os.system("aws s3 cp --recursive {} {}".format(intermediate_url, tmp_dir)) os.system("tar -xvzf {}/output.tar.gz -C {}".format(tmp_dir, tmp_dir)) print("\nCopied output files to 'tmp_dir': {}\n".format(tmp_dir)) ###Output 2020-03-29 18:36:45 Starting - Starting the training job... 2020-03-29 18:36:47 Starting - Launching requested ML instances...... 2020-03-29 18:37:48 Starting - Preparing the instances for training... 2020-03-29 18:38:45 Downloading - Downloading input data 2020-03-29 18:38:45 Training - Downloading the training image... 2020-03-29 18:39:04 Training - Training image download completed. Training in progress.bash: cannot set terminal process group (-1): Inappropriate ioctl for device bash: no job control in this shell 2020-03-29 18:39:07,540 sagemaker-containers INFO Imported framework sagemaker_mxnet_container.training 2020-03-29 18:39:07,544 sagemaker-containers INFO No GPUs detected (normal if no gpus installed) 2020-03-29 18:39:07,556 sagemaker_mxnet_container.training INFO MXNet training environment: {'SM_LOG_LEVEL': '20', 'SM_INPUT_DATA_CONFIG': '{}', 'SM_FRAMEWORK_MODULE': 'sagemaker_mxnet_container.training:main', 'SM_HP_RL.EVALUATION_STEPS:ENVIRONMENTEPISODES': '5', 'SM_INPUT_DIR': '/opt/ml/input', 'SM_OUTPUT_DATA_DIR': '/opt/ml/output/data', 'SM_FRAMEWORK_PARAMS': '{"sagemaker_estimator":"RLEstimator"}', 'SM_HPS': '{"RLCOACH_PRESET":"preset-portfolio-management-clippedppo","improve_steps":100000,"rl.agent_params.algorithm.discount":0.9,"rl.evaluation_steps:EnvironmentEpisodes":5,"training_epochs":10}', 'SM_HP_RL.AGENT_PARAMS.ALGORITHM.DISCOUNT': '0.9', 'SM_CHANNELS': '[]', 'SM_CURRENT_HOST': 'algo-1', 'SM_TRAINING_ENV': '{"additional_framework_parameters":{"sagemaker_estimator":"RLEstimator"},"channel_input_dirs":{},"current_host":"algo-1","framework_module":"sagemaker_mxnet_container.training:main","hosts":["algo-1"],"hyperparameters":{"RLCOACH_PRESET":"preset-portfolio-management-clippedppo","improve_steps":100000,"rl.agent_params.algorithm.discount":0.9,"rl.evaluation_steps:EnvironmentEpisodes":5,"training_epochs":10},"input_config_dir":"/opt/ml/input/config","input_data_config":{},"input_dir":"/opt/ml/input","job_name":"sagemaker-rl-mxnet-2020-03-29-18-36-44-773","log_level":20,"model_dir":"/opt/ml/model","module_dir":"s3://sagemaker-us-east-1-031118886020/sagemaker-rl-mxnet-2020-03-29-18-36-44-773/source/sourcedir.tar.gz","module_name":"train-coach","network_interface_name":"eth0","num_cpus":8,"num_gpus":0,"output_data_dir":"/opt/ml/output/data","output_dir":"/opt/ml/output","output_intermediate_dir":"/opt/ml/output/intermediate","resource_config":{"current_host":"algo-1","hosts":["algo-1"],"network_interface_name":"eth0"},"user_entry_point":"train-coach.py"}', 'SM_OUTPUT_DIR': '/opt/ml/output', 'SM_INPUT_CONFIG_DIR': '/opt/ml/input/config', 'SM_HP_IMPROVE_STEPS': '100000', 'SM_MODEL_DIR': '/opt/ml/model', 'SM_MODULE_NAME': 'train-coach', 'SM_NUM_GPUS': '0', 'SM_HP_TRAINING_EPOCHS': '10', 'SM_HP_RLCOACH_PRESET': 'preset-portfolio-management-clippedppo', 'SM_MODULE_DIR': 's3://sagemaker-us-east-1-031118886020/sagemaker-rl-mxnet-2020-03-29-18-36-44-773/source/sourcedir.tar.gz', 'SM_USER_ARGS': '["--RLCOACH_PRESET","preset-portfolio-management-clippedppo","--improve_steps","100000","--rl.agent_params.algorithm.discount","0.9","--rl.evaluation_steps:EnvironmentEpisodes","5","--training_epochs","10"]', 'SM_USER_ENTRY_POINT': 'train-coach.py', 'SM_OUTPUT_INTERMEDIATE_DIR': '/opt/ml/output/intermediate', 'SM_HOSTS': '["algo-1"]', 'SM_NUM_CPUS': '8', 'SM_NETWORK_INTERFACE_NAME': 'eth0', 'SM_RESOURCE_CONFIG': '{"current_host":"algo-1","hosts":["algo-1"],"network_interface_name":"eth0"}'} 2020-03-29 18:39:07,713 sagemaker-containers INFO Module train-coach does not provide a setup.py.  Generating setup.py 2020-03-29 18:39:07,713 sagemaker-containers INFO Generating setup.cfg 2020-03-29 18:39:07,713 sagemaker-containers INFO Generating MANIFEST.in 2020-03-29 18:39:07,714 sagemaker-containers INFO Installing module with the following command: /usr/bin/python -m pip install -U .  Processing /opt/ml/code Building wheels for collected packages: train-coach Running setup.py bdist_wheel for train-coach: started  Running setup.py bdist_wheel for train-coach: finished with status 'done' Stored in directory: /tmp/pip-ephem-wheel-cache-d18k2ksa/wheels/35/24/16/37574d11bf9bde50616c67372a334f94fa8356bc7164af8ca3 Successfully built train-coach Installing collected packages: train-coach Successfully installed train-coach-1.0.0 You are using pip version 18.1, however version 20.0.2 is available. You should consider upgrading via the 'pip install --upgrade pip' command. 2020-03-29 18:39:09,494 sagemaker-containers INFO No GPUs detected (normal if no gpus installed) 2020-03-29 18:39:09,506 sagemaker-containers INFO Invoking user script  Training Env:  { "framework_module": "sagemaker_mxnet_container.training:main", "channel_input_dirs": {}, "hosts": [ "algo-1" ], "additional_framework_parameters": { "sagemaker_estimator": "RLEstimator" }, "current_host": "algo-1", "output_data_dir": "/opt/ml/output/data", "hyperparameters": { "rl.agent_params.algorithm.discount": 0.9, "rl.evaluation_steps:EnvironmentEpisodes": 5, "RLCOACH_PRESET": "preset-portfolio-management-clippedppo", "training_epochs": 10, "improve_steps": 100000 }, "input_data_config": {}, "num_cpus": 8, "job_name": "sagemaker-rl-mxnet-2020-03-29-18-36-44-773", "num_gpus": 0, "module_name": "train-coach", "model_dir": "/opt/ml/model", "log_level": 20, "network_interface_name": "eth0", "user_entry_point": "train-coach.py", "resource_config": { "hosts": [ "algo-1" ], "current_host": "algo-1", "network_interface_name": "eth0" }, "output_dir": "/opt/ml/output", "output_intermediate_dir": "/opt/ml/output/intermediate", "input_config_dir": "/opt/ml/input/config", "module_dir": "s3://sagemaker-us-east-1-031118886020/sagemaker-rl-mxnet-2020-03-29-18-36-44-773/source/sourcedir.tar.gz", "input_dir": "/opt/ml/input" }  Environment variables:  SM_LOG_LEVEL=20 SM_INPUT_DATA_CONFIG={} SM_FRAMEWORK_MODULE=sagemaker_mxnet_container.training:main SM_OUTPUT_DATA_DIR=/opt/ml/output/data SM_HP_RL.EVALUATION_STEPS:ENVIRONMENTEPISODES=5 SM_FRAMEWORK_PARAMS={"sagemaker_estimator":"RLEstimator"} SM_HPS={"RLCOACH_PRESET":"preset-portfolio-management-clippedppo","improve_steps":100000,"rl.agent_params.algorithm.discount":0.9,"rl.evaluation_steps:EnvironmentEpisodes":5,"training_epochs":10} SM_HP_RL.AGENT_PARAMS.ALGORITHM.DISCOUNT=0.9 SM_CHANNELS=[] PYTHONPATH=/usr/local/bin:/usr/lib/python35.zip:/usr/lib/python3.5:/usr/lib/python3.5/plat-x86_64-linux-gnu:/usr/lib/python3.5/lib-dynload:/usr/local/lib/python3.5/dist-packages:/usr/lib/python3/dist-packages SM_CURRENT_HOST=algo-1 SM_OUTPUT_DIR=/opt/ml/output SM_INPUT_CONFIG_DIR=/opt/ml/input/config SM_USER_ARGS=["--RLCOACH_PRESET","preset-portfolio-management-clippedppo","--improve_steps","100000","--rl.agent_params.algorithm.discount","0.9","--rl.evaluation_steps:EnvironmentEpisodes","5","--training_epochs","10"] SM_HP_IMPROVE_STEPS=100000 SM_MODEL_DIR=/opt/ml/model SM_MODULE_NAME=train-coach SM_NUM_GPUS=0 SM_HP_TRAINING_EPOCHS=10 SM_HP_RLCOACH_PRESET=preset-portfolio-management-clippedppo SM_MODULE_DIR=s3://sagemaker-us-east-1-031118886020/sagemaker-rl-mxnet-2020-03-29-18-36-44-773/source/sourcedir.tar.gz SM_INPUT_DIR=/opt/ml/input SM_HOSTS=["algo-1"] SM_USER_ENTRY_POINT=train-coach.py SM_OUTPUT_INTERMEDIATE_DIR=/opt/ml/output/intermediate SM_TRAINING_ENV={"additional_framework_parameters":{"sagemaker_estimator":"RLEstimator"},"channel_input_dirs":{},"current_host":"algo-1","framework_module":"sagemaker_mxnet_container.training:main","hosts":["algo-1"],"hyperparameters":{"RLCOACH_PRESET":"preset-portfolio-management-clippedppo","improve_steps":100000,"rl.agent_params.algorithm.discount":0.9,"rl.evaluation_steps:EnvironmentEpisodes":5,"training_epochs":10},"input_config_dir":"/opt/ml/input/config","input_data_config":{},"input_dir":"/opt/ml/input","job_name":"sagemaker-rl-mxnet-2020-03-29-18-36-44-773","log_level":20,"model_dir":"/opt/ml/model","module_dir":"s3://sagemaker-us-east-1-031118886020/sagemaker-rl-mxnet-2020-03-29-18-36-44-773/source/sourcedir.tar.gz","module_name":"train-coach","network_interface_name":"eth0","num_cpus":8,"num_gpus":0,"output_data_dir":"/opt/ml/output/data","output_dir":"/opt/ml/output","output_intermediate_dir":"/opt/ml/output/intermediate","resource_config":{"current_host":"algo-1","hosts":["algo-1"],"network_interface_name":"eth0"},"user_entry_point":"train-coach.py"} SM_NUM_CPUS=8 SM_NETWORK_INTERFACE_NAME=eth0 SM_RESOURCE_CONFIG={"current_host":"algo-1","hosts":["algo-1"],"network_interface_name":"eth0"}  Invoking script with the following command:  /usr/bin/python -m train-coach --RLCOACH_PRESET preset-portfolio-management-clippedppo --improve_steps 100000 --rl.agent_params.algorithm.discount 0.9 --rl.evaluation_steps:EnvironmentEpisodes 5 --training_epochs 10  ###Markdown Plot the training history ###Code csv_file_name = "worker_0.simple_rl_graph.main_level.main_level.agent_0.csv" wait_for_s3_object(s3_bucket, os.path.join(intermediate_folder_key, csv_file_name), tmp_dir) df = pd.read_csv("{}/{}".format(tmp_dir, csv_file_name)).dropna(subset=['Evaluation Reward']) _ = df.plot(x=x_axis,y=y_axis, figsize=(11,3)) ###Output Waiting for s3://sagemaker-us-east-1-031118886020/sagemaker-rl-mxnet-2020-03-29-18-36-44-773/output/intermediate/worker_0.simple_rl_graph.main_level.main_level.agent_0.csv... Downloading sagemaker-rl-mxnet-2020-03-29-18-36-44-773/output/intermediate/worker_0.simple_rl_graph.main_level.main_level.agent_0.csv ###Markdown Plot the RL Policy performance against a buy and hold policy ###Code df = pd.read_csv(tmp_dir + '/portfolio-management.csv', index_col='date') _ = df[["portfolio_value", "market_value"]].plot(rot=30, figsize=(11,3)) ###Output _____no_output_____
module_8_calculus/training_linear_regression_model_using_gradient_descent.ipynb
###Markdown Training the linear regression model using Gradient Descent ###Code import numpy as np import pandas as pd from matplotlib import pyplot as plt ## load the dataset df = pd.read_csv("../data/housing_data.csv") df.head() ###Output _____no_output_____ ###Markdown * RM - average number of rooms per dwelling* AGE - proportion of owner-occupied units built prior to 1940* DIS - weighted distances to five Boston employment centres* RAD - index of accessibility to radial highways* TAX - full-value property-tax rate per USD10,000* PTRATIO - pupil-teacher ratio by town* B - 1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town* LSTAT - percentage lower status of the population* PRICE - Median value of owner-occupied homes in $1000's ###Code import seaborn as sns sns.heatmap(df.corr().abs(), annot=True) df['PRICE'] df['RM'] plt.scatter(df['RM'], df['PRICE']) plt.xlabel('RM') plt.ylabel('PRICE') X = df['RM'].to_numpy().reshape(-1, 1) X.shape y = df['PRICE'].to_numpy().reshape(-1, 1) y.shape from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X = scaler.fit_transform(X) y = scaler.fit_transform(y) def mean_sq_error(x, y, m): n = x.shape[0] loss = ((1 / 2*n)) * np.sum((m*x - y)**2) return loss def cost_fn_derivative(x, y, m): n = x.shape[0] cost_derivative = (1/n) * np.sum((m*x - y) * x) return cost_derivative m = 0 mean_sq_error(X, y, m) cost_fn_derivative(x=X, y=y, m=m) lr = 0.1 m = 0 m_iter = [] loss_iter = [] for i in range(40): m = m - lr * cost_fn_derivative(x=X, y=y, m=m) loss = mean_sq_error(X, y, m) m_iter.append(m) loss_iter.append(loss) m_iter loss_iter plt.scatter(m_iter, loss_iter, linewidths=1.5) plt.xlabel("Value of m") plt.ylabel("loss") m_iter[-1] x_data = np.linspace(-5, 5, 100) ###Output _____no_output_____
applications/notebooks/examples/scala/kmeans_over_single_GeoTiff.ipynb
###Markdown Kmeans over a single GeoTiffThis notebook shows how to read from Spark a single- and multi-band GeoTiff. We use [**GeoTrellis**](https://github.com/locationtech/geotrellis) to read the GeoTiff as a RDD, extracts from it a band, filters NaN and converts the result to a RDD of dense vectors. Such RDD is then passed to **Kmeans** cluster algorithm from **Spark-MLlib** for training. The kmeans model is then saved into HDFS.Note: In this example the grid cells define the dimension of the matrix. Since only the year **1980** is loaded, the matrix only has one record. To understand how to load several GeoTiffs and tranpose a matrix to have years the dimension of the matrix the reader should check [kmeans_multiGeoTiffs_matrixTranspose](kmeans_multiGeoTiffs_matrixTranspose.ipynb) notebooks in the scala examples. Dependencies ###Code import geotrellis.raster.MultibandTile import geotrellis.spark.io.hadoop._ import geotrellis.vector.ProjectedExtent import org.apache.hadoop.fs.Path import org.apache.spark.{SparkConf, SparkContext} import org.apache.spark.mllib.clustering.KMeans import org.apache.spark.mllib.linalg.Vectors import org.apache.spark.rdd.RDD ###Output _____no_output_____ ###Markdown Read GeoTiff into a RDD ###Code var band_NaN_RDD :RDD[Array[Double]] = sc.emptyRDD val single_band = True; var filepath :String = "" if (single_band) { //Single band GeoTiff filepath = "hdfs:///user/hadoop/spring-index/LastFreeze/1980.tif" } else { //Multi band GeoTiff filepath = "hdfs:///user/hadoop/spring-index/BloomFinal/1980.tif" } if (single_band) { //Lets load a Singleband GeoTiff and return RDD just with the tile. val bands_RDD = sc.hadoopGeoTiffRDD(filepath).values //Conversion to ArrayDouble is necessary to thne generate a Dense Vector band_NaN_RDD = bands_RDD.map( m => m.toArrayDouble()) } else { //Lets load a Multiband GeoTiff and return RDD just with the tiles. val bands_RDD = sc.hadoopMultibandGeoTiffRDD(filepath).values //Extract the 4th band band_NaN_RDD = bands_RDD.map( m => m.band(3).toArrayDouble()) } ###Output vector length with NaN is 30388736 vector length without NaN is 13695035 ###Markdown Manipulate the RDD ###Code //Go to each vector and print the length of each vector band_NaN_RDD.collect().foreach(m => println("vector length with NaN is %d".format(m.length))) //Go to each vector and filter out all NaNs val band_RDD = band_NaN_RDD.map(m => m.filter(v => !v.isNaN)) //Go to each vector and print the length of each vector to see how many NaN were removed band_RDD.collect().foreach(m => println("vector length without NaN is %d".format(m.length))) ###Output _____no_output_____ ###Markdown Create a RDD of dense Vectors ###Code // Create a Vector with NaN converted to 0s //val band_vec = band_NaN_RDD.map(s => Vectors.dense(s.map(v => if (v.isNaN) 0 else v))).cache() // Create a Vector without NaN values val band_vec = band_RDD.map(s => Vectors.dense(s)).cache() ###Output _____no_output_____ ###Markdown Train Kmeans ###Code val numClusters = 2 val numIterations = 20 val clusters = { KMeans.train(band_vec,numClusters,numIterations) } // Evaluate clustering by computing Within Set Sum of Squared Errors val WSSSE = clusters.computeCost(band_vec) println("Within Set Sum of Squared Errors = " + WSSSE) ###Output Within Set Sum of Squared Errors = 0.0 ###Markdown Save kmeans model ###Code //Un-persist the model band_vec.unpersist() // Shows the result. println("Cluster Centers: ") //clusters.clusterCenters.foreach(println) //Clusters save the model if (band_count == 1) { clusters.save(sc, "hdfs:///user/pheno/spring_index/LastFreeze/1980_kmeans_model") } else { clusters.save(sc, "hdfs:///user/pheno/spring_index/BloomFinal/1980_kmeans_model") } ###Output Cluster Centers:
OOP_Application_Example.ipynb
###Markdown ###Code class Person: def __init__(self, std, pre, mid, fin): self.__std = std self.__pre = pre self.__mid = mid self.__fin = fin def Terms(self): print(self.__std, self.__pre, self.__mid, self.__fin) print("Student Term Grades (Prelim, Midterm, Finals):") stu1 = Person("Student 1", 88, 89, 87) stu2 = Person("Student 2", 88, 87, 98) stu3 = Person("Student 3", 91, 90, 92) stu1.Terms() stu2.Terms() stu3.Terms() class Student(Person): def __init__(self, pre, mid, fin): self.__pre = pre self.__mid = mid self.__fin = fin def Grade(self): return((self.__pre + self.__mid + self.__fin)/3) print("Student Term Average:") std1 = Student(88, 89, 87) print("Student 1:", round(std1.Grade(), 2)) std2 = Student(88, 87, 90) print("Student 2:", round(std2.Grade(), 2)) std3 = Student(91, 90, 92) print("Student 3:", round(std3.Grade(), 2)) ###Output Student Term Grades (Prelim, Midterm, Finals): Student 1 88 89 87 Student 2 88 87 98 Student 3 91 90 92 Student Term Average: Student 1: 88.0 Student 2: 88.33 Student 3: 91.0
04-Visualization-Matplotlib-Pandas/04-02-Pandas Visualization/Visualizing Time Series Data.ipynb
###Markdown Visualizing Time Series DataLet's go through a few key points of creatng nice time visualizations! ###Code import pandas as pd import matplotlib.pyplot as plt %matplotlib inline # Optional for interactive (watch video for full details) #%matplotlib notebook mcdon = pd.read_csv('mcdonalds.csv',index_col='Date',parse_dates=True) mcdon.head() # Not Good! mcdon.plot() mcdon['Adj. Close'].plot() mcdon['Adj. Volume'].plot() mcdon['Adj. Close'].plot(figsize=(12,8)) mcdon['Adj. Close'].plot(figsize=(12,8)) plt.ylabel('Close Price') plt.xlabel('Overwrite Date Index') plt.title('Mcdonalds') mcdon['Adj. Close'].plot(figsize=(12,8),title='Pandas Title') ###Output _____no_output_____ ###Markdown Plot Formatting X Limits ###Code mcdon['Adj. Close'].plot(xlim=['2007-01-01','2009-01-01']) mcdon['Adj. Close'].plot(xlim=['2007-01-01','2009-01-01'],ylim=[0,50]) ###Output _____no_output_____ ###Markdown Color and Style ###Code mcdon['Adj. Close'].plot(xlim=['2007-01-01','2007-05-01'],ylim=[0,40],ls='--',c='r') ###Output _____no_output_____ ###Markdown X TicksThis is where you will need the power of matplotlib to do heavy lifting if you want some serious customization! ###Code import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib.dates as dates mcdon['Adj. Close'].plot(xlim=['2007-01-01','2007-05-01'],ylim=[0,40]) idx = mcdon.loc['2007-01-01':'2007-05-01'].index stock = mcdon.loc['2007-01-01':'2007-05-01']['Adj. Close'] idx stock ###Output _____no_output_____ ###Markdown Basic matplotlib plot ###Code fig, ax = plt.subplots() ax.plot_date(idx, stock,'-') #plot_date plt.tight_layout() ###Output _____no_output_____ ###Markdown Fix the overlap! ###Code fig, ax = plt.subplots() ax.plot_date(idx, stock,'-') #automatic format fig.autofmt_xdate() # Auto fixes the overlap! plt.tight_layout() ###Output _____no_output_____ ###Markdown Customize grid ###Code fig, ax = plt.subplots() ax.plot_date(idx, stock,'-') ax.yaxis.grid(True) ax.xaxis.grid(True) fig.autofmt_xdate() # Auto fixes the overlap! plt.tight_layout() ###Output _____no_output_____ ###Markdown Format dates on Major Axis ###Code fig, ax = plt.subplots() ax.plot_date(idx, stock,'-') # Grids ax.yaxis.grid(True) ax.xaxis.grid(True) # Major Axis ax.xaxis.set_major_locator(dates.MonthLocator()) ax.xaxis.set_major_formatter(dates.DateFormatter('%b\n%Y')) fig.autofmt_xdate() # Auto fixes the overlap! plt.tight_layout() plt.show() fig, ax = plt.subplots() ax.plot_date(idx, stock,'-') # Grids ax.yaxis.grid(True) ax.xaxis.grid(True) # Major Axis ax.xaxis.set_major_locator(dates.MonthLocator()) ax.xaxis.set_major_formatter(dates.DateFormatter('\n\n\n\n%Y--%B')) fig.autofmt_xdate() # Auto fixes the overlap! plt.tight_layout() plt.show() ###Output _____no_output_____ ###Markdown Minor Axis ###Code fig, ax = plt.subplots() ax.plot_date(idx, stock,'-') # Major Axis ax.xaxis.set_major_locator(dates.MonthLocator()) ax.xaxis.set_major_formatter(dates.DateFormatter('\n\n%Y--%B')) # Minor Axis ax.xaxis.set_minor_locator(dates.WeekdayLocator()) ax.xaxis.set_minor_formatter(dates.DateFormatter('%d')) # Grids ax.yaxis.grid(True) ax.xaxis.grid(True) fig.autofmt_xdate() # Auto fixes the overlap! plt.tight_layout() plt.show() fig, ax = plt.subplots(figsize=(10,8)) ax.plot_date(idx, stock,'-') # Major Axis ax.xaxis.set_major_locator(dates.WeekdayLocator(byweekday=1)) ax.xaxis.set_major_formatter(dates.DateFormatter('%B-%d-%a')) # Grids ax.yaxis.grid(True) ax.xaxis.grid(True) fig.autofmt_xdate() # Auto fixes the overlap! plt.tight_layout() ###Output _____no_output_____
Google_CoLab_XGB_Big5.ipynb
###Markdown ###Code from xgboost import XGBClassifier import numpy as np import pandas as pd from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score from sklearn.preprocessing import StandardScaler # https://stackoverflow.com/questions/57986259/multiclass-classification-with-xgboost-classifier # !unzip -q original.zip model = XGBClassifier (learning_rate=0.5, objective='multi:softmax') big5 = pd.read_csv ('big5.csv', sep='\t') big5.head() ###Output _____no_output_____
.ipynb_checkpoints/W-stacking-improved Optimised with decreased w-planes (W=4, x0=0.2)-checkpoint.ipynb
###Markdown Reference:Ye, H. (2019). Accurate image reconstruction in radio interferometry (Doctoral thesis). https://doi.org/10.17863/CAM.39448Haoyang Ye, Stephen F Gull, Sze M Tan, Bojan Nikolic, Optimal gridding and degridding in radio interferometry imaging, Monthly Notices of the Royal Astronomical Society, Volume 491, Issue 1, January 2020, Pages 1146–1159, https://doi.org/10.1093/mnras/stz2970Github: https://github.com/zoeye859/Imaging-Tutorial ###Code %matplotlib notebook import numpy as np from scipy.optimize import leastsq, brent from scipy.linalg import solve_triangular import matplotlib.pyplot as plt import scipy.integrate as integrate from time import process_time from numpy.linalg import inv np.set_printoptions(precision=6) from Imaging_core_new import * from Gridding_core import * import pickle with open("min_misfit_gridding_7_0p2.pkl", "rb") as pp: opt_funcs = pickle.load(pp) ###Output _____no_output_____ ###Markdown 1. Read in the data ###Code ######### Read in visibilities ########## data = np.genfromtxt('out_barray_6d.csv', delimiter = ',') jj = complex(0,1) u_original = data.T[0] v_original = data.T[1] w_original = -data.T[2] V_original = data.T[3] + jj*data.T[4] n_uv = len(u_original) uv_max = max(np.sqrt(u_original**2+v_original**2)) V,u,v,w = Visibility_minusw(V_original,u_original,v_original,w_original) #### Determine the pixel size #### X_size = 900 # image size on x-axis Y_size = 900 # image size on y-axis X_min = -np.pi/60. #You can change X_min and X_max in order to change the pixel size. X_max = np.pi/60. X = np.linspace(X_min, X_max, num=X_size+1)[0:X_size] Y_min = -np.pi/60. #You can change Y_min and Y_max in order to change the pixel size. Y_max = np.pi/60. Y = np.linspace(Y_min,Y_max,num=Y_size+1)[0:Y_size] pixel_resol_x = 180. * 60. * 60. * (X_max - X_min) / np.pi / X_size pixel_resol_y = 180. * 60. * 60. * (Y_max - Y_min) / np.pi / Y_size print ("The pixel size on x-axis is ", pixel_resol_x, " arcsec") ###Output The pixel size on x-axis is 23.999999999999996 arcsec ###Markdown 2. Determine w plane number Nw_2R ###Code W = 7 M, x0, h = opt_funcs[W].M, opt_funcs[W].x0, opt_funcs[W].h n0, w_values, dw = calcWgrid_offset(W, X_max, Y_max, w, x0, symm=True) ###Output We will have 26 w-planes ###Markdown 3 3D Gridding + Imaging + CorrectingTo know more about gridding, you can refer to https://github.com/zoeye859/Imaging-Tutorial Calculating gridding values for w respectively ###Code im_size = 2250 ind = find_nearestw(w_values, w) C_w = cal_grid_w(w, w_values, ind, dw, W, h, M, x0) ###Output Elapsed time during the w gridding value calculation in seconds: 8.187552365000101 ###Markdown Gridding on w-axis ###Code V_wgrid, u_wgrid, v_wgrid, beam_wgrid = grid_w_offset(V, u, v, w, C_w, w_values, W, len(w_values), ind, n0) ###Output Elapsed time during the w-gridding calculation in seconds: 2.3843892449999995 ###Markdown Imaging ###Code def grid_uv(V_update, u_update, v_update, beam_update, W, im_size, X_max, X_min, Y_max, Y_min, h, M, x0): """ Grid on u-axis and v-axis Args: V_update (np.narray): visibility data on the certain w-plane u_update (np.narray): u of the (u,v,w) coordinates on the certain w-plane v_update (np.narray): v of the (u,v,w) coordinates on the certain w-plane w_update (np.narray): w of the (u,v,w) coordinates on the certain w-plane W (int): support width of the gridding function """ V_grid = np.zeros((im_size,im_size),dtype = np.complex_) B_grid = np.zeros((im_size,im_size),dtype = np.complex_) C_u, u_grid = cal_grid_uv(u_update, W, im_size, X_max, X_min, h, M, x0) C_v, v_grid = cal_grid_uv(v_update, W, im_size, Y_max, Y_min, h, M, x0) for k in range(0,len(V_update)): C_uk = C_u[k] C_vk = C_v[k] if W % 2 == 1: u_index = np.int(np.around(u_grid[k])) v_index = np.int(np.around(v_grid[k])) else: u_index = np.int(np.floor(u_grid[k])) v_index = np.int(np.floor(v_grid[k])) u_k=0 for m in range(-W//2+1,-W//2+1+W): v_k=0 for n in range(-W//2+1,-W//2+1+W): V_grid[u_index+m,v_index+n] += C_uk[u_k] * C_vk[v_k] * V_update[k] B_grid[u_index+m,v_index+n] += C_uk[u_k] * C_vk[v_k] * beam_update[k] v_k+=1 u_k+=1 return V_grid, B_grid I_size = int(im_size*2*x0) I_image = np.zeros((I_size,I_size),dtype = np.complex_) B_image = np.zeros((I_size,I_size),dtype = np.complex_) t2_start = process_time() for w_ind in range(len(w_values)): print ('Gridding the ', w_ind, 'th level facet out of ', len(w_values),' w facets.\n') V_update = np.asarray(V_wgrid[w_ind]) u_update = np.asarray(u_wgrid[w_ind]) v_update = np.asarray(v_wgrid[w_ind]) beam_update = np.asarray(beam_wgrid[w_ind]) V_grid, B_grid = grid_uv(V_update, u_update, v_update, beam_update, W, im_size, X_max, X_min, Y_max, Y_min, h, M, x0) print ('FFT the ', w_ind, 'th level facet out of ', len(w_values),' w facets.\n') I_image += FFTnPShift_offset(V_grid, w_values[w_ind], X, Y, im_size, x0, n0) B_image += FFTnPShift_offset(B_grid, w_values[w_ind], X, Y, im_size, x0, n0) B_grid = np.zeros((im_size,im_size),dtype = np.complex_) V_grid = np.zeros((im_size,im_size),dtype = np.complex_) t2_stop = process_time() print("Elapsed time during imaging in seconds:", t2_stop-t2_start) ###Output Gridding the 0 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.36680272800003877 Elapsed time during the u/v gridding value calculation in seconds: 0.36454913099987607 FFT the 0 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 1 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 2.305769428000076 Elapsed time during the u/v gridding value calculation in seconds: 2.289033023999991 FFT the 1 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 2 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 3.8411090659999445 Elapsed time during the u/v gridding value calculation in seconds: 3.8169645559999026 FFT the 2 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 3 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 4.942067829000052 Elapsed time during the u/v gridding value calculation in seconds: 4.923582562999854 FFT the 3 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 4 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 5.815981094000108 Elapsed time during the u/v gridding value calculation in seconds: 5.829218212999876 FFT the 4 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 5 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 6.510376555999983 Elapsed time during the u/v gridding value calculation in seconds: 6.47194761500009 FFT the 5 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 6 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 7.023058178999918 Elapsed time during the u/v gridding value calculation in seconds: 7.00615604099994 FFT the 6 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 7 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 7.067264843000203 Elapsed time during the u/v gridding value calculation in seconds: 7.109062306999931 FFT the 7 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 8 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 5.479340631000014 Elapsed time during the u/v gridding value calculation in seconds: 5.480119515000069 FFT the 8 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 9 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 4.1769611770000665 Elapsed time during the u/v gridding value calculation in seconds: 4.19470699600015 FFT the 9 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 10 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 3.3027111640001294 Elapsed time during the u/v gridding value calculation in seconds: 3.2969850169999972 FFT the 10 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 11 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 2.5296875610001734 Elapsed time during the u/v gridding value calculation in seconds: 2.5101788789997954 FFT the 11 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 12 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 1.9537372330000835 Elapsed time during the u/v gridding value calculation in seconds: 1.9322258929998952 FFT the 12 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 13 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 1.4234372910000275 Elapsed time during the u/v gridding value calculation in seconds: 1.4228298709999763 FFT the 13 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 14 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 1.042621987000075 Elapsed time during the u/v gridding value calculation in seconds: 1.0356624859998647 FFT the 14 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 15 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.7313754649999282 Elapsed time during the u/v gridding value calculation in seconds: 0.7170594720000736 FFT the 15 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 16 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.4879663930000788 Elapsed time during the u/v gridding value calculation in seconds: 0.4816383559998485 FFT the 16 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 17 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.3114565210000819 Elapsed time during the u/v gridding value calculation in seconds: 0.3085141300000487 FFT the 17 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 18 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.1880746790000103 Elapsed time during the u/v gridding value calculation in seconds: 0.18781221300014295 FFT the 18 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 19 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.11067428199999085 Elapsed time during the u/v gridding value calculation in seconds: 0.11153932999991412 FFT the 19 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 20 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.0689003990000856 Elapsed time during the u/v gridding value calculation in seconds: 0.06829192499981218 FFT the 20 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 21 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.03835078500014788 Elapsed time during the u/v gridding value calculation in seconds: 0.0379822449999665 FFT the 21 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 22 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.024912316999916584 Elapsed time during the u/v gridding value calculation in seconds: 0.024506475000180217 FFT the 22 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 23 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.013887522000004537 Elapsed time during the u/v gridding value calculation in seconds: 0.013434985000003508 FFT the 23 th level facet out of 26 w facets. FFTing... Phaseshifting... FFTing... Phaseshifting... Gridding the 24 th level facet out of 26 w facets. Elapsed time during the u/v gridding value calculation in seconds: 0.005102541000042038 Elapsed time during the u/v gridding value calculation in seconds: 0.004718458000070314 FFT the 24 th level facet out of 26 w facets. FFTing... Phaseshifting... ###Markdown Rescale and have a look ###Code I_image_now = image_rescale(I_image,im_size, n_uv) B_image_now = image_rescale(B_image,im_size, n_uv) plt.figure() plt.imshow(np.rot90(I_image_now.real,1), origin = 'lower') plt.xlabel('Image Coordinates X') plt.ylabel('Image Coordinates Y') plt.show() B_image_now[450,450] ###Output _____no_output_____ ###Markdown Correcting functions h(x)h(y) on x and y axis W= 4, x0 = 0.2 ###Code def xy_correct(I, opt_func, im_size, x0): """ Rescale the obtained image Args: W (int): support width of the gridding function im_size (int): the image size, it is to be noted that this is before the image cropping opt_func (np.ndarray): The vector of grid correction values sampled on [0,x0) to optimize I (np.narray): summed up image Return: I_xycorrected (np.narray): corrected image on x,y axis """ I_size = int(im_size*2*x0) x = np.arange(-im_size/2, im_size/2)/im_size h_map = get_grid_correction(opt_func, x) index_x = int((0.5+x0)*im_size) index_y = int((0.5+x0)*im_size) #index_x = int(I_size * 1.5) #index_y = int(I_size * 1.5) temp = np.delete(h_map,np.s_[0:(im_size - index_x)],0) Cor_gridx = np.delete(temp,np.s_[I_size:index_x],0) #correcting function on x-axis Cor_gridy = np.delete(temp,np.s_[I_size:index_y],0) #correcting function on y-axis I_xycorrected = np.zeros([I_size,I_size],dtype = np.complex_) for i in range(0,I_size): for j in range(0,I_size): I_xycorrected[i,j] = I[i,j] * Cor_gridx[i] * Cor_gridy[j] return I_xycorrected I_xycorrected = xy_correct(I_image_now, opt_funcs[W], im_size, x0=0.2) B_xycorrected = xy_correct(B_image_now, opt_funcs[W], im_size, x0=0.2) plt.figure() plt.imshow(np.rot90(I_xycorrected.real,1), origin = 'lower') plt.xlabel('Image Coordinates X') plt.ylabel('Image Coordinates Y') plt.show() B_xycorrected[450,450] ###Output _____no_output_____ ###Markdown Correcting function on z axis ###Code def z_correct_cal_offset(lut, X_min, X_max, Y_min, Y_max, dw, h, im_size, W, M, x0, n0=1): """ Return: Cor_gridz (np.narray): correcting function on z-axis by Sze """ I_size = int(im_size*2*x0) nu, x = make_evaluation_grids(W, M, I_size) gridder = calc_gridder(h, x0, nu, W, M) grid_correction = gridder_to_grid_correction(gridder, nu, x, W) print (grid_correction[:I_size].shape) #h_map = np.zeros(im_size, dtype=float) #h_map[I_size:] = grid_correction[:I_size] #h_map[:I_size] = grid_correction[:0:-1] xrange = X_max - X_min yrange = Y_max - Y_min ny = im_size nx = im_size l_map = np.linspace(X_min, X_max, nx+1)[:nx]/(2*x0) m_map = np.linspace(Y_min, Y_max, ny+1)[:ny]/(2*x0) ll, mm = np.meshgrid(l_map, m_map) # Do not allow NaN or values outside the x0 for the optimal function z = abs(dw*(np.sqrt(np.maximum(0.0, 1. - ll**2 - mm**2))-n0)) z[z > x0] = x0 fmap = lut.interp(z) Cor_gridz = image_crop(fmap, im_size, x0) return Cor_gridz lut = setup_lookup_table(opt_funcs[7], 256, 7, x0) Cor_gridz = z_correct_cal_offset(lut, X_min, X_max, Y_min, Y_max, dw, h, im_size, W, M, x0, n0) I_zcorrected = z_correct(I_xycorrected, Cor_gridz, im_size, x0=0.25) B_zcorrected = z_correct(B_xycorrected, Cor_gridz, im_size, x0=0.25) #np.savetxt('I_Figure6.csv', I_zcorrected.real, delimiter = ',') ###Output (900,) ###Markdown 4 DFT and FFT dirty image difference ###Code I_DFT = np.loadtxt('I_DFT_900_out6db.csv', delimiter = ',') I_dif = I_DFT - I_zcorrected.real plt.figure() plt.imshow(np.rot90(I_dif,1), origin = 'lower') plt.colorbar() plt.xlabel('Image Coordinates X') plt.ylabel('Image Coordinates Y') plt.show() rms = RMS(I_dif, im_size, 1, x0=0.2) print (rms) from astropy.io import fits fits_file = 'out_1800.flux.fits' hdu_list = fits.open(fits_file) pbcor = hdu_list[0].data hdu_list.close() pbcor = pbcor.reshape((1800,1800)) pbcor = pbcor[450:1350,450:1350] I_dif_r = I_rotation(900,I_dif) I_dif_r_pbcor = pb_cor(pbcor,900,I_dif_r) np.savetxt('Difference_W4_x2.csv',I_dif_r_pbcor, delimiter=',') I_diff_47planes = np.loadtxt('Difference_47planes.csv', delimiter = ',') #I_diff_186planes = np.loadtxt('Difference_186planes.csv', delimiter = ',') I_diff_470planes = np.loadtxt('Difference_470planes.csv', delimiter = ',') I_diff_10000planes = np.loadtxt('Difference_10000planes.csv', delimiter = ',') I_diff = np.loadtxt('Difference_improved.csv', delimiter = ',') I_diff1 = np.loadtxt('Difference_W4_x25.csv', delimiter = ',') I_diff2 = np.loadtxt('Difference_W4_x2.csv', delimiter = ',') rms47 = np.zeros(450) #rms186 = np.zeros(450) rms470 = np.zeros(450) rms10000 = np.zeros(450) rms = np.zeros(450) rms1 = np.zeros(450) rms2 = np.zeros(450) j = 0 for i in np.arange(0,450,1): rms47[j] = np.sqrt(np.mean(I_diff_47planes[i:(900-i),i:(900-i)]**2)) #rms186[j] = np.sqrt(np.mean(I_diff_186planes[i:(900-i),i:(900-i)]**2)) rms470[j] = np.sqrt(np.mean(I_diff_470planes[i:(900-i),i:(900-i)]**2)) rms10000[j] = np.sqrt(np.mean(I_diff_10000planes[i:(900-i),i:(900-i)]**2)) rms[j] = np.sqrt(np.mean(I_diff[i:(900-i),i:(900-i)]**2)) rms1[j] = np.sqrt(np.mean(I_diff1[i:(900-i),i:(900-i)]**2)) rms2[j] = np.sqrt(np.mean(I_diff2[i:(900-i),i:(900-i)]**2)) j=j+1 plt.figure() i = np.arange(0,450,1) x = (450-i)/450/2 plt.semilogy(x,rms47, label = 'W-Stacking (W=7,x0=0.25,47 planes)') #plt.semilogy(x,rms186, label = 'W-Stacking (186 planes)') plt.semilogy(x,rms470, label = 'W-Stacking (W=7,x0=0.25,470 planes)') plt.semilogy(x,rms10000, label = 'W-Stacking (W=7,x0=0.25,10000 planes)') plt.semilogy(x,rms, label = 'Improved W-Stacking (W=7,x0=0.25,22 planes)') plt.semilogy(x,rms1, label = 'Improved W-Stacking (W=4,x0=0.25,19 planes)') plt.semilogy(x,rms2, label = 'Improved W-Stacking (W=4,x0=0.2,23 planes)') #plt.ylim(1e-7,1e-1) plt.title(r'RMS of image misfit') plt.xlabel('Normalised image plane coordinate') plt.ylabel('RMS of image misfit') plt.grid() plt.legend(bbox_to_anchor=(1.1, 1.05)) plt.show() plt.savefig('RMS_comparison_W4_2.png', dpi=300, bbox_inches='tight') ###Output _____no_output_____
2-xarray-example/1-basic-xarray.ipynb
###Markdown xarray还有一个数据处理的库非常好用 -- xarray。本文参考以下资料,简单记录下xarray的基本使用方法。- [xarray官方文档](http://xarray.pydata.org/en/stable/)- [Pangeo Tutorial Gallery / Xarray Tutorial](http://gallery.pangeo.io/repos/pangeo-data/pangeo-tutorial-gallery/xarray.html)xarray是一个专门用来处理多维标签数据的python库。Xarray在类似于**NumPy的原始数组上以维度,坐标和属性的形式引入标签**,从而提供了更直观,更简洁和更少出错的开发人员体验。引入标签的原因是现实世界中,数据往往不是原始的多维数组,而还包含一系列反映数据编码信息的标签,比如时空信息。xarray可以利用这些标签更好地完成对数据的操作,后面会根据实际使用逐步记录。Xarray借鉴了pandas,特别适合处理netCDF文件,netcdf是xarray数据模型的来源,如果不了解netcdf可以参考:[netcdf-python 介绍](https://github.com/OuyangWenyu/aqualord/blob/master/DataFormat/netcdf.ipynb)。xarray中最基本的数据结构是DataArray和Dataset,前者类似于pandas里的Series,后者类似DataFrame,更多信息后面记录。例如,下图显示了一个“数据立方体”数据,其中温度和降水共享相同的三个维度,以及作为辅助坐标的经度和纬度。![](pictures/dataset-diagram.png)另外xarray还与dask紧密集成以进行并行计算,后面用到dask再做记录。conda安装:```Shell 官方网站的推荐安装conda install -c conda-forge xarray dask netCDF4 bottleneck``` 基本术语以下无明确说明时,arr 表示DataArray对象。- DataArray:是一个多维数组,有标签,如果name属性设置了,就成为一个named DataArray- Dataset:一个类dict的DataArray对象集合,有多个排列的维度。Datasets有 Varaible- Varaible:类似于netcdf的variable,包含维度,数据,属性等。variables和numpy数组的主要区别是变量上的广播运算基于维度名称的。每个DataArray有一个潜在variable可以通过arr.variable访问。Variable在Dataset和DataArray内的,所以不必单独用它。- Dimension:一个维度轴就是固定一个维度上的所有点的集合。每个维度轴有一个名字,比如x维度。DataArray对象的维度就是被命名的维度轴。第i个维度名称可用arr.dim[i]获取。默认的维度名称是dim_0,dim_1以此类推。- Coordinate:一个标记维度的数组。在一维情况下,坐标数组的至可以被认为是维度的标签。有两种坐标: - Dimension coordinate:一维的坐标数组用名字和维度名字指定给arr,可见于arr.dims。维度坐标类似于DataFrame中的index。 - Non-dimension coordinate:非维度坐标可见于arr.coords,这些坐标数组可以是一维也可以是多维,多维情况主要见于物理坐标和逻辑坐标不一致的时候,非维度坐标是不能索引的。- Index:index是优化数据结构用于快速索引和切片的。xarray用维度坐标可以i快速索引。以上有些晦涩,接下来看例子。 基本数据结构先看DataArray,多维标记数组。 DataArray ###Code import numpy as np data = np.random.rand(4, 3) data import pandas as pd locs = ['IA', 'IL', 'IN'] times = pd.date_range('2000-01-01', periods=4) times import xarray as xr foo = xr.DataArray(data, coords=[times, locs], dims=['time', 'space']) foo ###Output _____no_output_____ ###Markdown 可以看到这个arr有两个坐标,一个时间,一个空间,时间对应一个坐标数组,是pandas的data_range,空间对应一个list,相应的数据有4 * 3=12个,且数组共4行,对应4个时间,三列对应三个空间。最简单的初始化方式是直接使用data': ###Code xr.DataArray(data) ###Output _____no_output_____ ###Markdown 可以看到默认的坐标。另外,可以直接使用字典形式创建coords: ###Code xr.DataArray(data, coords=[('time', times), ('space', locs)]) ###Output _____no_output_____ ###Markdown 再比如多维的: ###Code xr.DataArray(data, coords={'time': times, 'space': locs, 'const': 42, 'ranking': (('time', 'space'), np.arange(12).reshape(4,3))}, dims=['time', 'space']) ###Output _____no_output_____ ###Markdown 如上,time和space是维度坐标,const和ranking就是非维度坐标。维度是直接和数据对应上的,其他非维度的坐标是其他和数据不直接对应的。另外,还可以使用DataFrame来初始化: ###Code df = pd.DataFrame({'x': [0, 1], 'y': [2, 3]}, index=['a', 'b']) df df.index.name = 'abc' df df.columns.name = 'xyz' df xr.DataArray(df) ###Output _____no_output_____ ###Markdown 接下来看看数组的属性: ###Code foo.values ###Output _____no_output_____ ###Markdown 注意DataArray中的数组值都是统一的数据类型。如果需要不同数据类型的,那么需要使用Dataset。 ###Code foo.dims foo.coords foo.attrs print(foo.name) ###Output None ###Markdown 以上有缺失默认值的,可以使用下列方式补充: ###Code foo.name = 'foo' foo.attrs['units'] = 'meters' foo ###Output _____no_output_____ ###Markdown 使用rename会返回一个新的数据数组: ###Code foo.rename('bar') ###Output _____no_output_____ ###Markdown 坐标是类似dict类型的 ###Code foo.coords['time'] foo['time'] ###Output _____no_output_____ ###Markdown 坐标可以被删除: ###Code foo['ranking'] = ('space', [1, 2, 3]) foo.coords del foo['ranking'] foo.coords ###Output _____no_output_____ ###Markdown 稍微小结下 DataArray:首先主体还是一个数组,数组的坐标直接对应维度坐标,比如一个二维的数组,那么就有两个维度坐标,数组中每个数据都唯一对应一对维度坐标值;还可以有非维度坐标,另外还有描述DataArray属性的。下面看Dataset,它就是为netcdf定制的。可以简单地认为 Dataset 就是多个具有相同坐标系的 DataArray 的组合体。 Dataset ###Code temp = 15 + 8 * np.random.randn(2, 2, 3) temp precip = 10 * np.random.rand(2, 2, 3) precip lon = [[-99.83, -99.32], [-99.79, -99.23]] lat = [[42.25, 42.21], [42.63, 42.59]] ds = xr.Dataset({'temperature': (['x', 'y', 'time'], temp), 'precipitation': (['x', 'y', 'time'], precip)}, coords={'lon': (['x', 'y'], lon), 'lat': (['x', 'y'], lat), 'time': pd.date_range('2014-09-06', periods=3), 'reference_time': pd.Timestamp('2014-09-05')}) ds ###Output _____no_output_____ ###Markdown 可以直接传入DataArray到Dataset,或者DataFrame。 ###Code xr.Dataset({'bar': foo}) type(foo.to_pandas()) xr.Dataset({'bar': foo.to_pandas()}) ###Output _____no_output_____ ###Markdown variable 就是 组成 Dataset 的 DataArray 的名字,也就是上面初始化时候 用的 dict 的 key。像dict中使用key那样在Dataset中使用 variable 即可取出 DataArray: ###Code 'temperature' in ds ds['temperature'] ###Output _____no_output_____ ###Markdown 或者: ###Code ds.temperature ###Output _____no_output_____ ###Markdown Dataset的变量: ###Code ds.data_vars ###Output _____no_output_____ ###Markdown Dataset的坐标: ###Code ds.coords ###Output _____no_output_____ ###Markdown Dataset的属性: ###Code ds.attrs ds.attrs['title'] = 'example attribute' ds ###Output _____no_output_____ ###Markdown Dataset的长度是指的是变量的个数。 ###Code len(ds) ###Output _____no_output_____ ###Markdown 如果想要保存 Dataset,最自然的方法自然是保存到 netcdf 文件。 ###Code ds.to_netcdf("saved_on_disk.nc") ###Output _____no_output_____ ###Markdown 在xarray中读取netcdf文件可以这样: ###Code ds_disk = xr.open_dataset("saved_on_disk.nc") ds_disk ###Output _____no_output_____ ###Markdown 简单运算示例xarray的DataArray计算和numpy的array计算是一致的,所以至少形式上,两者可以保持一致,这对python编程也是很有利的.下面是具体的例子. ###Code import numpy as np import xarray as xr ###Output _____no_output_____ ###Markdown 现在构建 f(x)=sin(x) ###Code x = np.linspace(-np.pi, np.pi, 19) f = np.sin(x) ###Output _____no_output_____ ###Markdown 把数据放入DataArray ###Code da_f = xr.DataArray(f) da_f ###Output _____no_output_____ ###Markdown 完善数据的信息 ###Code da_f = xr.DataArray(f, dims=['x']) da_f da_f = xr.DataArray(f, dims=['x'], coords={'x': x}) da_f ###Output _____no_output_____ ###Markdown xarray还有像pandas那样的方便绘图功能,也是由matplotlib提供的,如果还没安装过,使用conda安装即可,关于可视化,后续会有更多记录。 ###Code da_f.plot(marker='o') ###Output _____no_output_____ ###Markdown 索引数据和numpy中的indexing和slicing一致 ###Code # get the 10th item da_f[10] # get the first 10 items da_f[:10] ###Output _____no_output_____ ###Markdown 不过在xarray中更强大的是 .sel() 函数,来进行带标签的索引,这样能根据坐标来索引 ###Code da_f.sel(x=0) da_f.sel(x=slice(0, np.pi)).plot() ###Output _____no_output_____ ###Markdown 基本运算当对xarray DataArrays进行数学运算时,坐标随之而来。假设我们要计算: $g=f^2+1$,那么可以像在numpy中运算一样: ###Code da_g = da_f**2 + 1 da_g da_g.plot() ###Output _____no_output_____ ###Markdown 处理多维数据相比于单维数据和numpy,pandas类似的能力,xarray在处理多维数据方面有更多的优势.手动下载下数据, 在本文件夹下执行:```Shellgit clone https://github.com/pangeo-data/tutorial-data.git```读取示例netcdf文件数据: ###Code import xarray as xr ds = xr.open_dataset('./tutorial-data/sst/NOAA_NCDC_ERSST_v3b_SST-1960.nc') ds # both do the exact same thing # dictionary syntax sst = ds['sst'] # attribute syntax sst = ds.sst sst ###Output _____no_output_____ ###Markdown 下面是多维索引,选择特定日期的数据 ###Code sst.sel(time='1960-06-15').plot(vmin=-2, vmax=30) ###Output _____no_output_____ ###Markdown 还可以沿任何axis选择值: ###Code sst.sel(lon=180).transpose().plot() sst.sel(lon=180, lat=40).plot() ###Output _____no_output_____ ###Markdown 下面是一些数据分析的例子,对数据做"减法",统计如均值,标准差,最值的信息.比如,针对所有维度: ###Code sst.mean() # 对float数据, 默认是skip nan值的 sst.mean(skipna=True) sst_time_mean = sst.mean(dim='time') sst_time_mean.plot(vmin=-2, vmax=30) sst_zonal_mean = sst.mean(dim='lon') sst_zonal_mean.transpose().plot() sst_time_and_zonal_mean = sst.mean(dim=('time', 'lon')) sst_time_and_zonal_mean.plot() # some might prefer to have lat on the y axis sst_time_and_zonal_mean.plot(y='lat') ###Output _____no_output_____ ###Markdown 下面是一个更复杂的例子,计算加权平均温度. 因为球面上每个微元的面积并不一样, 所以需要计算出来然后面积加权.计算球面上一个微元的面积:$$\delta A = R^2 \delta\phi \delta\lambda cos(\phi)$$其中,$\phi$是维度,$\lambda$是经度,单位都是弧度. R是地球半径. ###Code import numpy as np R = 6.37e6 # we know already that the spacing of the points is one degree latitude dϕ = np.deg2rad(1.) dλ = np.deg2rad(1.) dA = R**2 * dϕ * dλ * np.cos(np.deg2rad(ds.lat)) dA.plot() ###Output _____no_output_____ ###Markdown 其中,ds.lat 是将维度取出来, 维度是坐标,所以取出来数据是一维的, 也是DataArray ###Code ds.lat ###Output _____no_output_____ ###Markdown 对应的dA也是相同结构 ###Code dA ###Output _____no_output_____ ###Markdown 可以将数据扩充到lat和lon作为坐标的DataArray上, 利用where函数即可, where函数不仅可以判断索引, 还具备广播能力 ###Code dA.where(sst[0].notnull()) ###Output _____no_output_____ ###Markdown 可以看到 ###Code sst[0] sst[0].notnull() ###Output _____no_output_____ ###Markdown 在为True的地方, 会根据坐标 lat 的值实现广播.下面绘图看看: ###Code pixel_area = dA.where(sst[0].notnull()) pixel_area.plot() total_ocean_area = pixel_area.sum(dim=('lon', 'lat')) sst_weighted_mean = (sst * pixel_area).sum(dim=('lon', 'lat')) / total_ocean_area sst_weighted_mean.plot() ###Output _____no_output_____ ###Markdown xarray 还可以一次性打开多个 文件, 写入一个dataset. 使用 open_mfdataset 函数即可. ###Code ds_all = xr.open_mfdataset('./tutorial-data/sst/*nc', combine='by_coords') ds_all ###Output _____no_output_____ ###Markdown 现在57年的数据都在其中.接着尝试一些运算, 先看看 groupby ###Code sst_clim = ds_all.sst.groupby('time.month').mean(dim='time') sst_clim ###Output _____no_output_____
docs/source/load_data.ipynb
###Markdown Load rheology data If you have a google account you can run this documentation notebook [Open in colab](https://colab.research.google.com/github/rheopy/rheofit/blob/master/docs/source/load_data.ipynb) ###Code from IPython.display import clear_output !pip install git+https://github.com/rheopy/rheofit.git --upgrade clear_output() import rheofit import numpy as np import pandas as pd import pybroom as pb import matplotlib.pyplot as plt import seaborn as sns sns.set_style('whitegrid') ###Output _____no_output_____ ###Markdown The module rheofit.rheodata provides a class to store structured rheology data.We initially focus loading datafile exported by the trios software in two possible format:* Excel format - as structured by the trios software with the multitab export opion* Rheoml format [rheoml link](https://www.tomcoat.com/IUPAC/index.php?Page=XML%20Repository) Import data from Multitab excel (assuming format exported by TA Trios) ###Code # Download example of xls file format import requests url = 'https://github.com/rheopy/rheofit/raw/master/docs/source/_static/Flow_curve_example.xls' r = requests.get(url, allow_redirects=True) with open('Flow_curve_example.xls', 'wb') as file: file.write(r.content) excel_file=pd.ExcelFile('Flow_curve_example.xls') excel_file.sheet_names flow_curve=rheofit.rheodata.rheology_data('Flow_curve_example.xls') flow_curve.filename flow_curve.Details flow_curve[0] print(flow_curve[0][0]) flow_curve[0][1] print(flow_curve[1][0]) flow_curve[1][1] # In summary flow_curve=rheofit.rheodata.rheology_data('Flow_curve_example.xls') for (label,data) in flow_curve: plt.loglog('Shear rate','Stress',data=data,marker='o',label=label) plt.xlabel('$\dot\gamma$') plt.ylabel('$\sigma$') plt.legend() flow_curve.tidy import altair as alt alt.Chart(flow_curve.tidy).mark_point().encode( alt.X('Shear rate', scale=alt.Scale(type='log')), alt.Y('Stress', scale=alt.Scale(type='log')), color='stepname') #.interactive() ###Output _____no_output_____ ###Markdown Import data from Rheoml ###Code # Download example of xls file format import requests url = 'https://raw.githubusercontent.com/rheopy/rheofit/master/docs/source/_static/Flow_curve_example.xml' r = requests.get(url, allow_redirects=True) with open('Flow_curve_example.xml', 'wb') as file: file.write(r.content) # In summary from xml (rheoml schema) # to do - add to rheology_data class the option to import from xml # Solve naming problem for shear stress and shear rate steps_table_list=rheofit.rheodata.dicttopanda(rheofit.rheodata.get_data_dict('Flow_curve_example.xml')) for data in steps_table_list: plt.loglog('ShearRate','ShearStress',data=data,marker='o') plt.xlabel('$\dot\gamma$') plt.ylabel('$\sigma$') plt.legend() ###Output _____no_output_____
hw5/train/RNN_feature_extractor.ipynb
###Markdown training sample for seq2seq prediciton ###Code def normalize(image): ''' normalize for pre-trained model input ''' normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform_input = transforms.Compose([ transforms.ToPILImage(), transforms.Pad((0,40), fill=0, padding_mode='constant'), transforms.Resize(224), # transforms.CenterCrop(224), # transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize ]) return transform_input(image) # load data from FullLength folder # training set print("training set .....") with torch.no_grad(): video_path = "../HW5_data/FullLengthVideos/videos/train/" category_list = sorted(listdir(video_path)) category = category_list[1] train_all_video_frame = [] # cnn_feature_extractor = torchvision.models.densenet121(pretrained=True).features.cuda() model = torchvision.models.resnet101(pretrained=True) cnn_feature_extractor = nn.Sequential(*list(model.children())[:-1]).cuda() for category in category_list: print("category:",category) image_list_per_folder = sorted(listdir(os.path.join(video_path,category))) category_frames = [] for image in image_list_per_folder: image_rgb = skimage.io.imread(os.path.join(video_path, category,image)) image_nor = normalize(image_rgb) feature = cnn_feature_extractor(image_nor.view(1,3,224,224).cuda()).cpu().view(2048) # 1024*7*7 if use densenet category_frames.append(feature) train_all_video_frame.append(torch.stack(category_frames)) print("\nvalidation set .....") video_path = "../HW5_data/FullLengthVideos/videos/valid/" category_list = sorted(listdir(video_path)) category = category_list[1] test_all_video_frame = [] for category in category_list: print("category:",category) image_list_per_folder = sorted(listdir(os.path.join(video_path,category))) category_frames = [] for image in image_list_per_folder: image_rgb = skimage.io.imread(os.path.join(video_path, category,image)) image_nor = normalize(image_rgb) feature = cnn_feature_extractor(image_nor.view(1,3,224,224).cuda()).cpu().view(2048) category_frames.append(feature) test_all_video_frame.append(torch.stack(category_frames)) with open("train_FullLength_features_resnet.pkl", "wb") as f: pickle.dump(train_all_video_frame, f) with open("valid_FullLength_features_resnet.pkl", "wb") as f: pickle.dump(test_all_video_frame, f) ###Output _____no_output_____ ###Markdown Cut to defined size ###Code with open("../features/train_FullLength_features_resnet.pkl", "rb") as f: train_all_video_frame = pickle.load(f) with open("../features/valid_FullLength_features_resnet.pkl", "rb") as f: valid_all_video_frame = pickle.load(f) # load ground truth label_path = "../HW5_data/FullLengthVideos/labels/train/" category_txt_list = sorted(listdir(label_path)) train_category_labels = [] for txt in category_txt_list: file_path = os.path.join(label_path,txt) with open(file_path,"r") as f: label = [int(w.strip()) for w in f.readlines()] train_category_labels.append(label) label_path = "../HW5_data/FullLengthVideos/labels/valid/" category_txt_list = sorted(listdir(label_path)) valid_category_labels = [] for txt in category_txt_list: file_path = os.path.join(label_path,txt) with open(file_path,"r") as f: label = [int(w.strip()) for w in f.readlines()] valid_category_labels.append(label) ###Output _____no_output_____ ###Markdown using "slice" function in torch ###Code def cut_frames(features_per_category, labels_per_category, size = 200, overlap = 20): feature_size = 50176 a = torch.split(features_per_category, size-overlap) b = torch.split(torch.Tensor(labels_per_category), size-overlap) cut_features = [] cut_labels = [] for i in range(len(a)): if i==0: cut_features.append(a[i]) cut_labels.append(b[i]) else: cut_features.append(torch.cat((a[i-1][-overlap:],a[i]))) cut_labels.append(torch.cat((b[i-1][-overlap:],b[i]))) lengths = [len(f) for f in cut_labels] return cut_features, cut_labels, lengths r1, r2, r3 = cut_frames(train_all_video_frame[0],train_category_labels[0], size = 120, overlap = 10) cutting_steps = 350 overlap_steps = 30 train_cut_features = [] train_cut_labels = [] train_cut_lengths = [] for category_frames, category_labels in zip(train_all_video_frame,train_category_labels): features, labels, lengths = cut_frames(category_frames,category_labels, size = cutting_steps, overlap = overlap_steps) train_cut_features += features train_cut_labels += labels train_cut_lengths += lengths print("one category done") valid_lengths = [len(s) for s in valid_all_video_frame] valid_lengths with open("../features/train_cut_features_350_30_resnet.pkl", "wb") as f: pickle.dump(train_cut_features,f) with open("../features/train_cut_labels_350_30_resnet.pkl", "wb") as f: pickle.dump(train_cut_labels,f) with open("../features/train_cut_lengths_350_30_resnet.pkl", "wb") as f: pickle.dump(train_cut_lengths,f) with open("../features/valid_cut_features_no_cut_resnet.pkl", "wb") as f: pickle.dump(valid_all_video_frame,f) with open("../features/valid_cut_labels_no_cut_resnet.pkl", "wb") as f: pickle.dump(valid_category_labels,f) with open("../features/valid_cut_lengths_no_cut_resnet.pkl", "wb") as f: pickle.dump(valid_lengths,f) ###Output _____no_output_____
projector.ipynb
###Markdown TensorBoard DependenciesNote: the following dependencies were **not included** in the project's requirements file:* tensorflow* tensorboard* torch ###Code # Load in the used dependencies import os import numpy as np import tensorflow as tf import tensorboard as tb tf.io.gfile = tb.compat.tensorflow_stub.io.gfile from torch.utils.tensorboard import SummaryWriter import pandas as pd import seaborn as sns import matplotlib.pyplot as plt ###Output _____no_output_____ ###Markdown Data Hyperparameters ###Code LOG_DIR = './population_backup/storage/experiment6/' topology_id = 3 overwrite = True rm_duplicates = False # Remove all samples with at least 'dup_columns' duplicate values dup_columns = None # Number of duplicated columns a single sample has before removal filter_score = True # Filter out samples having a fitness of min_fitness or more classify = True # Classify the samples based on the connections if topology_id in [2,3,222,3333]: min_fitness = 1 # GRU is capable of finding all targets elif topology_id in [22]: min_fitness = 0.6 # Best score of 11/18 else: raise Exception(f"Add topology ID '{topology_id}'") ###Output _____no_output_____ ###Markdown Fetch ###Code # Setup the header head = ['fitness'] if topology_id in [1, 2, 3]: # GRU populations head += ['bias_r', 'bias_z', 'bias_h', 'weight_xr', 'weight_xz', 'weight_xh', 'weight_hr', 'weight_hz', 'weight_hh'] elif topology_id in [22, 33]: # SRU populations head += ['bias_h', 'weight_xh', 'weight_hh'] elif topology_id in [2222, 3333]: head += ['bias_z', 'bias_h', 'weight_xz', 'weight_xh', 'weight_hz', 'weight_hh'] elif topology_id in [222, 333]: head += ['delay', 'scale', 'resting'] else: raise Exception(f"Topology ID '{topology_id}' not supported!") if topology_id in [1]: head += ['conn1', 'conn2'] elif topology_id in [2, 22, 222, 2222]: head += ['bias_rw', 'conn2'] elif topology_id in [3, 33, 333, 3333]: head += ['bias_rw', 'conn0', 'conn1', 'conn2'] else: raise Exception(f"Topology ID '{topology_id}' not supported!") # Check if tsv files already exist raw_path = os.path.join(LOG_DIR, f'topology_{topology_id}/data/topology_{topology_id}.csv') data_path = os.path.join(LOG_DIR, f'topology_{topology_id}/data/data.tsv') meta_path = os.path.join(LOG_DIR, f'topology_{topology_id}/data/meta.tsv') # Load in the data (without header) if not overwrite and os.path.exists(data_path): data = np.genfromtxt(data_path, delimiter='\t') meta = np.genfromtxt(meta_path, delimiter='\t') else: raw = np.genfromtxt(raw_path, delimiter=',')[1:] data = raw[:,:-1] meta = raw[:,-1] np.savetxt(data_path, data, delimiter='\t') np.savetxt(meta_path, meta, delimiter='\t') # Print shape: print(f"Data shape: {data.shape}") print(f"Meta shape: {meta.shape}") # Transform to pandas dataframe (easier to manipulate) data_pd = pd.DataFrame(data, columns=head[1:]) meta_pd = pd.DataFrame(meta, columns=head[:1]) data_pd.head() meta_pd.head() ###Output _____no_output_____ ###Markdown Filter the data ###Code # Filter out the complete duplicates indices = data_pd.duplicated() data_pd = data_pd[~indices.values] meta_pd = meta_pd[~indices.values] print(f"Data shape: {data_pd.shape}") print(f"Meta shape: {meta_pd.shape}") # For example, if you want to see only fitnesses of 1 (perfect score). if filter_score: indices = meta_pd >= min_fitness data_pd = data_pd[indices.values] meta_pd = meta_pd[indices.values] print(f"Data shape: {data_pd.shape}") print(f"Meta shape: {meta_pd.shape}") # Filter out all the samples that have at least one duplicate value (in each of its columns) if rm_duplicates: indices = (meta_pd<0).astype(int).values.flatten() # Little hack for h in head[1:]: indices += data_pd.duplicated(subset=h).astype(int).values # Remove all that exceed the set threshold data_pd = data_pd[indices < dup_columns] meta_pd = meta_pd[indices < dup_columns] print(f"Dropping duplicates that occur in {dup_columns} columns or more") print(f" > Data shape: {data_pd.shape}") print(f" > Meta shape: {meta_pd.shape}") data_pd.head() ###Output _____no_output_____ ###Markdown Visualize the dataRemark: Symmetry in data clearly by conn1 (this is the connection between GRU node and output of the global network) ###Code # indices = (data_pd['bias_rw'] >= 2) & (data_pd['conn2'] >= -3) indices = (data_pd['bias_rw'] != 0) temp = data_pd[indices.values] print(f"Data shape: {temp.shape}") plt.figure(figsize=(15,3)) temp.boxplot() plt.ylim(-6,6) plt.show() plt.close() for i, v in enumerate(temp.values): a = abs(v[3]-2.1088881375106086) b = abs(v[4]+2.819266855899976) if a+b < 1: print(i, "-", a+b,"-", round(a,3), "-", round(b,3)) temp.head() temp.values[1][4] plt.figure(figsize=(15,3)) data_pd.boxplot() plt.show() plt.close() def adapt_and_show(data, indices=None): data_temp = data if indices is not None: data_temp = data_temp[indices.values] print(f"Size: {data_temp.shape}") plt.figure(figsize=(15,5)) for i, h in enumerate(head[1:]): plt.subplot(int(len(head)/6+1),6,i+1) sns.violinplot(data_temp[h]) plt.title(h) if 'delay' in h: continue if 'bias' in h or 'resting' in h: plt.xlim(-3,3) else: plt.xlim(-6,6) plt.yticks([]) plt.tight_layout() plt.show() plt.close() # indices = (data_pd['conn1'] > 0) & (data_pd['conn0'] > 0) indices = None adapt_and_show(data_pd, indices) # h = 'bias_h' # t = '$c_0$' # plt.figure(figsize=(3,1.3)) # sns.violinplot(data_pd[h]) # plt.title(t) # if 'bias' in h: # plt.xlim(-3,3) # else: # plt.xlim(-6,6) # plt.ylim(0) # plt.yticks([]) # plt.xlabel('') # plt.tight_layout() # plt.savefig(f"delete_me/{h}.png", bbox_inches='tight', pad_inches=0.02) # plt.show() # plt.close() ###Output _____no_output_____ ###Markdown Add columnAdd a class column, used for visualisation in the Projector. ###Code def classify_connections(r): if r['conn0'] >= 0 and r['conn1'] >= 0: return "PP" # Positive Positive elif r['conn0'] >= 0 and r['conn1'] < 0: return "PN" # Positive Negative elif r['conn0'] < 0 and r['conn1'] >= 0: return "NP" # Negative Positive else: return "NN" # Negative Negative classes = None if classify: classes = data_pd.apply(lambda row: classify_connections(row), axis=1).values ###Output _____no_output_____ ###Markdown FormatCreate labels for visualisation. ###Code # Create better labels meta_str = [] for d, m in zip(data_pd.values, meta_pd.values): s = [str(round(m[0], 2))] s += [str(round(x, 5))for x in d] meta_str.append(s) if classify: if 'classes' not in head: head.insert(0, 'classes') for i, m in enumerate(meta_str): meta_str[i].insert(0, classes[i]) # Example print(f"Data example: \n> {data_pd.values[0]}") print(f"Label example: \n> {meta_str[0]}") print(f"For header: \n> {head}") ###Output Data example: > [ 1.37952784 1.2845938 -1.31854468 2.00584058 1.1426045 1.14685034 1.28932122 -1.62728255 -2.0571236 2.42080414 4.51275769 4.15302192 -4.97156486] Label example: > ['PP', '1.0', '1.37953', '1.28459', '-1.31854', '2.00584', '1.1426', '1.14685', '1.28932', '-1.62728', '-2.05712', '2.4208', '4.51276', '4.15302', '-4.97156'] For header: > ['classes', 'fitness', 'bias_r', 'bias_z', 'bias_h', 'weight_xr', 'weight_xz', 'weight_xh', 'weight_hr', 'weight_hz', 'weight_hh', 'bias_rw', 'conn0', 'conn1', 'conn2'] ###Markdown MagicFolder in which data is stored is "runs/topology_1" (always keep "runs"). Change this is you want to compare several configurations. ###Code %%capture # Fire up the TensorBoard writer = SummaryWriter(log_dir=f"runs/topology_{topology_id}") # Overwrites if already exists writer.add_embedding(data_pd.to_numpy(), meta_str, metadata_header=head) writer.close() %load_ext tensorboard %tensorboard --logdir=runs # Tensorboard can be opened in separate tab: localhost:6006 ###Output warning: Embedding dir exists, did you set global_step for add_embedding()?
notebooks/scrubbed/covid-19-tests-august-2020.ipynb
###Markdown Trying to predict number of COVID-19 tests by August 1st 2020*Notebook by Steven Rybicki*In this notebook, we'll be focusing on trying to predict the number of COVID-19 tests in the US. Namely, we'll be looking at forecasting the answer to:> By August 1, how many tests for COVID-19 will have been administered in the US?taken from the [Metaculus question](https://pandemic.metaculus.com/questions/4400/by-august-1-how-many-tests-for-covid-19-will-have-been-administered-in-the-us/). This just looks at number of tests, not distinguishing by type or if someone is tested multiple times.To do this, we're going to be using [Ergo](https://github.com/oughtinc/ergo), a library by [Ought](https://ought.org/). This lets you integrate model based forecasting (building up a numerical model to predict outcomes) with judgement based forecasting (using calibration to predict outcomes less formally). To see other notebooks using Ergo, see [the Ergo repo](https://github.com/oughtinc/ergo/tree/master/notebooks). I'll be trying to walk through how you'd use this realistically if you wanted to forecast the answer to a question without investing a lot of time on exploration. This means our model will be kind of rough, but hopefully accurate enough to provide value, and I'll be iteratively trying to improve it as we go along. Notebook setupThis imports libraries, and sets up some useful functions ###Code %%capture !pip install --progress-bar off poetry !pip install --progress-bar off git+https://github.com/oughtinc/ergo.git@e9f6463de652f4e15d7c9ab0bb9f067fef8847f7 import warnings import ssl warnings.filterwarnings(action="ignore", category=FutureWarning) warnings.filterwarnings(action="ignore", module="plotnine") ssl._create_default_https_context = ssl._create_unverified_context import ergo import seaborn import numpy as np import pandas as pd from datetime import timedelta, date, datetime import matplotlib.pyplot as plt pd.set_option('precision', 2) def summarize_samples(samples): """ Print out the p5, p50 and p95 of the given sample """ stats = samples.describe(percentiles=[0.05, 0.5, 0.95]) percentile = lambda pt: float(stats.loc[f"{pt}%"]) return f"{percentile(50):.2f} ({percentile(5):.2f} to {percentile(95):.2f})" def show_marginal(func): """ Use Ergo to generate 1000 samples of the distribution of func, and then plot them as a distribution. """ samples = ergo.run(func, num_samples=1000)["output"] seaborn.distplot(samples).set_title(func.__doc__); plt.show() print(f"Median {func.__doc__}: {summarize_samples(samples)}") ###Output _____no_output_____ ###Markdown How are we going to predict this? PrinciplesHere's a couple things we're going to try to do when predicting this:- *fermi estimate / decomposition*: focus on decomposing the question into multiple parts that we can estimate separately. We'll start with our overall question (how many tests) and decompose it into smaller questions that are easier to predict (e.g. what's the estimated number of tests we will make tomorrow?).- *use live data*: where possible, fetch data from an up to date source. This lets us easily update our guess, as we can just rerun the notebook and it will update our prediction based on updated data. - *wisdom of the crowds*: incorporate other predictions, namely the [Metaculus one](https://pandemic.metaculus.com/questions/4400/by-august-1-how-many-tests-for-covid-19-will-have-been-administered-in-the-us/), so we can include information we might have missed. Question decompositionLet's decompose our question into a number of sub questions. We'll then focus on trying to estimate each of these separately, allowing us to iteratively improve our model as we go along.So the number of tests done by August 1st could be decomposed as: - ensemble prediction of: - my prediction - current number of tests done to date: how many tests have we done up until today? - how much we can expect that number to change until August 1st? - if current rates remain unchanged, what will that number be in August? - what change in testing rates should we expect based on past changes? - what will be the impact of future factors on testing rates? - metaculus question My Prediction Get relevant dataTo know the current testing rate, and how it changes, we're going to use the https://covidtracking.com/ API to fetch the testing statistics. To make it easier to parse, we're going to filter to the fields we care about:- date- totalTestResults: culmulative tests per day- totalTestResultsIncrease: how many new test results were reported that day ###Code testing_data = pd.read_csv("https://covidtracking.com/api/v1/us/daily.csv") # testing data uses numbers for dates (20200531 for e.g.), so let's convert that to use python dates instead testing_data["date"] = testing_data["date"].apply(lambda d: datetime.strptime(str(d), "%Y%m%d")) # now filter just to the columns we care about testing_data = testing_data[["date", "totalTestResults", "totalTestResultsIncrease"]] testing_data ###Output _____no_output_____ ###Markdown Current number of testsWe can now use our dataset to easily find the number of tests done today (or the latest in the dataset), which we can verify is correct by looking at the table above ###Code # pick the largest, therefore most up to date, date current_date = testing_data["date"].max() # if there's multiple entries for a day for whatever reason, take the first current_test_number = testing_data.loc[testing_data["date"] == current_date]["totalTestResults"][0] current_date, current_test_number ###Output _____no_output_____ ###Markdown How much can we expect this to change until August 1st?We now want to predict how many new tests we can expect from now until August 1st. One easy way to do this:- look at the distribution of new tests per day over the last month- if we simulate what happens if we continue like this until August 1st, what distribution do we expect? Distribution of tests over the past monthFirst, let's look at the `totalTestResultsIncrease` over the past month. ###Code last_month = current_date - timedelta(days=30) test_data_over_last_month = testing_data[testing_data['date'].between(last_month, current_date)] seaborn.distplot(test_data_over_last_month["totalTestResultsIncrease"]) ###Output _____no_output_____ ###Markdown Now, we want to use this to help build a model. Since we're using Ergo, this is easy: we just create a function that represents this field, which returns a random sample from the dataset. Then, to simulate the distribution of this field, we can sample from this function a large number of times. This is what the `show_marginal` function does, as well as plotting the resulting distribution. ###Code def test_results_increase_per_day(): "# test results per day" return ergo.random_choice(list(test_data_over_last_month["totalTestResultsIncrease"])) show_marginal(test_results_increase_per_day) ###Output _____no_output_____ ###Markdown As a sanity check, this distribution looks very similar as plotting the distribution above, which makes sense as they should be equivalent since the above is just randomly sampling from the original.Right now, this isn't especially useful: we've just created a similar distribution to one we had originally. But now that we've created this in Ergo, it becomes easy to manipulate and combine this with other distributions. We'll be doing this to extrapolate how many tests we can expect by August. How much we can expect that to increase by August 1st? Repeating our current ratesNow, using our new `test_results_increase_per_day` function, can we extrapolate what the number of tests tomorrow could look like? One way to do this: - look at test results today, `current_test_number`- sample from our `test_results_increase_per_day` distribution, add it to how many we have so farSince `test_results_increase_per_day` returns a sample from this distribution, this just looks like adding `current_test_number` to `test_results_increase_per_day`. ###Code def test_results_tomorrow(): "# test results tomorrow" return current_test_number + test_results_increase_per_day() show_marginal(test_results_tomorrow) ###Output _____no_output_____ ###Markdown Can we extend this to extrapolate further in the future? One simple way to do this (which we'll refine later): call `test_results_increase_per_day()` for each day in the future we want to forecast, and add them together. We could also just do `totalTestResultsIncrease() * number_of_days`, but this approach lets us sample more points and better approximate the potential increase. To verify this is working in a sensible way, let's test it for tomorrow: ###Code def test_results_for_date(date: datetime): number_of_days = (date - current_date).days return current_test_number + sum(test_results_increase_per_day() for _ in range(number_of_days)) def test_results_for_date_tomorrow(): "# test results tomorrow using test_results_for_date" return test_results_for_date(current_date + timedelta(days=1)) show_marginal(test_results_for_date_tomorrow) ###Output _____no_output_____ ###Markdown At least in my notebook, these show the exact same answer. So, now, if we want to predict for August, we can just change the date given. ###Code def test_results_for_deadline(): "# test results for August 1st" return test_results_for_date(datetime(2020, 8, 1)) show_marginal(test_results_for_deadline) ###Output _____no_output_____ ###Markdown Note that with Ergo, we can just use normal python operators and functions (`+, sum`) to sample from `test_results_increase_per_day()` and create this new distribution `test_results_for_date`. This lets us focus on building our model, and not have to worry about the math of combining distributions. What change in testing rates should we expect based on past changes?The above analysis assumes that number of tests per day is not increasing, as if it is we'll be underestimating. Let's validate that, and look at how the number of tests has changed over time. ###Code # create a days column, since that will help us make the x-axis look cleaner # (dates overlap with a smaller graph) first_date = testing_data["date"].min() testing_data["days"] = \ testing_data["date"].apply(lambda d: (d - first_date).days) seaborn.lineplot(x="days", y="totalTestResultsIncrease", data=testing_data) ###Output _____no_output_____ ###Markdown So we can see that roughly, month over month, the number of tests per day are increasing linearly. This means that our `test_results_for_deadline()` model above is probably underestimating the number of tests, as it's assuming the testing capacity remains static. What we want is to estimate the day over day increase, and use that to increase the number of tests our model is adding per day. Since it looks very linear right now, let's use a linear regression to estimate the slope of increases. We'll look at data when we past 100 000 cases, as that's where the trend seems to become linear. ###Code # ignore early testing data, as it was mostly zero, then growing exponentially test_data_worth_looking_at = testing_data[testing_data['totalTestResults'] >= 100000] # do a linear regression using scipy from scipy import stats slope_of_test_increases = stats.linregress(test_data_worth_looking_at["days"], test_data_worth_looking_at["totalTestResultsIncrease"]).slope slope_of_test_increases ###Output _____no_output_____ ###Markdown Now, with this in hand, we can modify our previous estimate by using this slope. ###Code def test_results_for_date_with_slope(date: datetime): number_of_days = (date - current_date).days return current_test_number + sum(test_results_increase_per_day() + slope_of_test_increases * day for day in range(number_of_days)) def test_results_for_deadline_with_slope(): "# test results for August 1st with linear increase in tests" return test_results_for_date_with_slope(datetime(2020, 8, 1)) show_marginal(test_results_for_deadline_with_slope) ###Output _____no_output_____ ###Markdown What will be the impact of future factors on testing rates?Right now, our model is potentially a bit too overconfident. Testing might not increase linearly at this rate forever:- we might increase testing rate, because of: - changes in testing policy to increase number of tests - outbreaks that intensify in regions - tests that are cheaper - more infrastructure to deploy tests - etc.- we might decrease testing rate, because of: - changes in testing policy to decrease the number of tests, to try understate the impact of the disease - containment strategies working well - hitting capacity limits on test manufacture - not being able to import any tests due to shortages in other countries - etc.We could go down the rabbit hole of trying to predict each of these, but that would take a ton of time, and not necessarily change the prediction much. The cheaper time-wise thing to do is to try estimate how much we expect testing rates to change in the future. This is using the judgement based forecasting we mentioned above. I'm going to guess that linear growth is still possible until August, but that it could be anything from 0.25 to 2 current growth per day. we're going to approximate this with a lognormal distribution, as we think that the most likely rate is around 1, but don't want to discount values at the tails. ###Code def estimated_slope(): "# estimated slope" return ergo.lognormal_from_interval(0.5, 2) * slope_of_test_increases show_marginal(estimated_slope) ###Output _____no_output_____ ###Markdown Now we can adapt our previous model, just using this estimated slope instead. ###Code def test_results_for_date_with_slope(date: datetime): # The slightly more correct way of doing this would be to replace estimated_slope() * day with repeated calls # to estimated_slope. But as we're predicing kind of far into the future, this makes the simulation really slow. number_of_days = (date - current_date).days return current_test_number + sum(test_results_increase_per_day() + estimated_slope() * day for day in range(number_of_days)) def test_results_for_deadline_with_slope(): "# test results for August 1st with linear increase in tests" return test_results_for_date_with_slope(datetime(2020, 8, 1)) show_marginal(test_results_for_deadline_with_slope) ###Output _____no_output_____ ###Markdown Incorporating the Metaculus predictionNow that we have our own prediction, let's look at the Metaculus one. This will give us a sense of how our model stacks up to their community's model, and is a good sanity check to see if we missed something obvious. If you're running this notebook, remember to replace the credentials below with your own. ###Code metaculus = ergo.Metaculus(username="oughtpublic", password="123456", api_domain="pandemic") testing_question = metaculus.get_question(4400, name="# tests administered") testing_question.show_community_prediction() ###Output _____no_output_____ ###Markdown This is similar to our prediction, just less certain (longer tails) and centered slightly higher. Since we think they have valuable information we might have missed, we're going to create a simple essemble prediction: pick randomly between a prediction the Metaculus community would make, and we would make, to create a combined model.Seaborn at time of writing has difficult plotting a distribution plot for this, because of some large outliers in the sample, so let's use a boxplot instead. This also helps show how to use Ergo outside of our `show_marginal` function. ###Code def ensemble_prediction(): "# ensemble prediction" if ergo.flip(0.5): return testing_question.sample_community() else: return test_results_for_deadline_with_slope() # use ergo to create a distribution from 1000 samples, using our ensemble prediction # this is output as a pandas dataframe, making it easy to plot and manipulate samples = ergo.run(ensemble_prediction, num_samples=1000)["output"] # show them as a box plot seaborn.boxplot(samples) print("Median:", summarize_samples(samples)) ###Output _____no_output_____ ###Markdown This shows a distribution similar to the one we had, just less certain, and with some probability for the long tails. Submitting to metaculusIf we want to, we can now submit this model to Metaculus. ###Code # below commented out to avoid accidentally submitting an answer when you don't mean to # samples = ergo.run(ensemble_prediction, num_samples=1000)["output"] # testing_question.submit_from_samples(samples) ###Output _____no_output_____ ###Markdown SummaryTo create this model, we did the following:- we fetched the latest data from https://covidtracking.com/- estimated the growth of the number of tests to be a combination of the past linear growth, and a log-normal distribution- used that to extrapolate the number of tests we'd have in August- then combined that prediction with the metaculus prediction, to create a final forecast for number of tests on August 1stSince we did a lot of iteration on our model, I'm including a cleaned up version of the entire thing below, so you can see everything at once. ###Code class Covid19TestsModel(object): def __init__(self, testing_data, testing_question): self.testing_data = testing_data self.testing_question = testing_question self.last_month = current_date - timedelta(days=30) self.current_date = testing_data["date"].max() # if there's multiple entries for a day for whatever reason, take the first self.current_test_number = testing_data.loc[testing_data["date"] == current_date]["totalTestResults"][0] # data subsets self.test_data_over_last_month = self.testing_data[testing_data['date'].between(last_month, current_date)] # calculate slope test_data_worth_looking_at = testing_data[testing_data['totalTestResults'] >= 100000] self.slope_of_test_increases = stats.linregress( test_data_worth_looking_at["days"], test_data_worth_looking_at["totalTestResultsIncrease"]).slope def test_results_increase_per_day(self): """ Estimated test increase over the past day looking at increases over the last month """ return ergo.random_choice(list(self.test_data_over_last_month["totalTestResultsIncrease"])) def estimated_slope(self): """ Estimated slope of increase of tests per day looking at linear regression of test cases, and a log-normal prediction of the possible changes """ return ergo.lognormal_from_interval(0.5, 2) * self.slope_of_test_increases def test_results_for_date_with_slope(self, date: datetime): """ Estimated test results for date, estimating based on the number of estimated test results per day including the estimated rate of increase """ number_of_days = (date - self.current_date).days return self.current_test_number + \ sum(self.test_results_increase_per_day() + self.estimated_slope() * day for day in range(number_of_days)) def test_results_for_deadline_with_slope(self): return self.test_results_for_date_with_slope(datetime(2020, 8, 1)) def ensemble_prediction(self): "# ensemble prediction" if ergo.flip(0.5): return self.testing_question.sample_community() else: return self.test_results_for_deadline_with_slope() show_marginal(Covid19TestsModel(testing_data, testing_question).ensemble_prediction) ###Output _____no_output_____
codes/labs_lecture04/lab01_linear_module/linear_module_exercise.ipynb
###Markdown Lab 04.01 : Linear module -- exercise Inspecting a linear module ###Code import torch import torch.nn as nn ###Output _____no_output_____ ###Markdown Make a linear module WITHOUT bias that takes input of size 2 and return output of size 3. ###Code mod= # complete here print(mod) ###Output _____no_output_____ ###Markdown Print the internal parameters of the module. Try to print the bias and double check that it return you "None" ###Code print( # complete here ) print( # complete here ) ###Output _____no_output_____ ###Markdown Make a vector $x=\begin{bmatrix}1\\1 \end{bmatrix}$ and feed it to your linear module. What is the output? ###Code x= # complete here print(x) y= # complete here print(y) ###Output _____no_output_____ ###Markdown Change the internal parameters of your module so that the weights become $W=\begin{bmatrix}1&2 \\ 3&4 \\ 5&6\end{bmatrix}$. You need to write 6 lines, one per entry to be changed. ###Code # complete here # complete here # complete here # complete here # complete here # complete here print(mod.weight) ###Output _____no_output_____ ###Markdown Feed the vector x to your module with updated parameters. What is the output? ###Code y= # complete here print(y) ###Output _____no_output_____
Panda.ipynb
###Markdown Loading in Data ###Code import pandas as pd !wget https://raw.githubusercontent.com/lazyprogrammer/machine_learning_examples/master/pytorch/aapl_msi_sbux.csv df = pd.read_csv('aapl_msi_sbux.csv',error_bad_lines=False); df = pd.read_csv('https://github.com/sammanthp007/Stock-Price-Prediction-Using-KNN-Algorithm/blob/master/sbux.csv',error_bad_lines=False); type(df) !head aapl_msi_sbux.csv.1 df.info() ###Output <class 'pandas.core.frame.DataFrame'> RangeIndex: 1259 entries, 0 to 1258 Data columns (total 3 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 AAPL 1259 non-null float64 1 MSI 1259 non-null float64 2 SBUX 1259 non-null float64 dtypes: float64(3) memory usage: 29.6 KB ###Markdown Select Columns and Rows ###Code df.columns df.head() df['AAPL'] type(df['AAPL']) type(df[['AAPL','MSI']]) df.iloc[0] df.loc[0] df2 = pd.read_csv('aapl_msi_sbux.csv',index_col='AAPL') df2.head() df2.loc[67.8542] df[df['AAPL'] > 67] df[df['AAPL'] != 67.8542] import numpy as np A = np.arange(10) A A[A % 2 == 0] df.values type(df.values) A = df.values df.to_csv('output.csv') !head output.csv df.to_csv('output2.csv',index=False) !head output2.csv ###Output AAPL,MSI,SBUX 67.8542,60.3,28.185 68.5614,60.9,28.07 66.8428,60.83,28.13 66.7156,60.81,27.915 66.6556,61.12,27.775 65.7371,61.43,27.17 65.7128,62.03,27.225 64.1214,61.26,26.655 63.7228,60.88,26.675 ###Markdown The apply() Function ###Code def date_to_year(row): return int(row['AAPL'] + 1) df.apply(date_to_year,axis = 1) ###Output _____no_output_____ ###Markdown Plotting with Panda ###Code df['AAPL'].hist(); df['AAPL'].plot(); df[['AAPL','MSI','SBUX']].plot.box(); from pandas.plotting import scatter_matrix scatter_matrix(df[['AAPL','MSI','SBUX']],alpha=0.2); ###Output _____no_output_____
docs/_sources/dl/dl.ipynb
###Markdown General Below serves some key concepts in ml, dl, and more. ###Code import numpy as np ###Output _____no_output_____ ###Markdown ReferencesGradeint Descent: Coursera Standford NLP course Perceptrons Multi-layer Network Gradient Descent / Logistic regression SigmoidYou will learn to use logistic regression for text classification. * The sigmoid function is defined as: $$ h(z) = \frac{1}{1+\exp^{-z}} \tag{1}$$It maps the input 'z' to a value that ranges between 0 and 1, and so it can be treated as a probability. Figure 1 ###Code def sigmoid(z): ''' Input: z: is the input (can be a scalar or an array) Output: h: the sigmoid of z ''' ### START CODE HERE ### # calculate the sigmoid of z h = None h = 1 / (1 + np.exp(-z) ) ### END CODE HERE ### return h ###Output _____no_output_____ ###Markdown Update the weightsTo update your weight vector $\theta$, you will apply gradient descent to iteratively improve your model's predictions. The gradient of the cost function $J$ with respect to one of the weights $\theta_j$ is:$$\nabla_{\theta_j}J(\theta) = \frac{1}{m} \sum_{i=1}^m(h^{(i)}-y^{(i)})x^{(i)}_j \tag{5}$$* 'i' is the index across all 'm' training examples.* 'j' is the index of the weight $\theta_j$, so $x^{(i)}_j$ is the feature associated with weight $\theta_j$* To update the weight $\theta_j$, we adjust it by subtracting a fraction of the gradient determined by $\alpha$:$$\theta_j = \theta_j - \alpha \times \nabla_{\theta_j}J(\theta) $$* The learning rate $\alpha$ is a value that we choose to control how big a single update will be. **Note**- h = hypothesis = calculated target. - y = ground truth Instructions: Implement gradient descent function* The number of iterations 'num_iters" is the number of times that you'll use the entire training set.* For each iteration, you'll calculate the cost function using all training examples (there are 'm' training examples), and for all features.* Instead of updating a single weight $\theta_i$ at a time, we can update all the weights in the column vector: $$\mathbf{\theta} = \begin{pmatrix}\theta_0\\\theta_1\\ \theta_2 \\ \vdots\\ \theta_n\end{pmatrix}$$* $\mathbf{\theta}$ has dimensions (n+1, 1), where 'n' is the number of features, and there is one more element for the bias term $\theta_0$ (note that the corresponding feature value $\mathbf{x_0}$ is 1).* The 'logits', 'z', are calculated by multiplying the feature matrix 'x' with the weight vector 'theta'. $z = \mathbf{x}\mathbf{\theta}$ * $\mathbf{x}$ has dimensions (m, n+1) * $\mathbf{\theta}$: has dimensions (n+1, 1) * $\mathbf{z}$: has dimensions (m, 1)* The prediction 'h', is calculated by applying the sigmoid to each element in 'z': $h(z) = sigmoid(z)$, and has dimensions (m,1).* The cost function $J$ is calculated by taking the dot product of the vectors 'y' and 'log(h)'. Since both 'y' and 'h' are column vectors (m,1), transpose the vector to the left, so that matrix multiplication of a row vector with column vector performs the dot product.$$J = \frac{-1}{m} \times \left(\mathbf{y}^T \cdot log(\mathbf{h}) + \mathbf{(1-y)}^T \cdot log(\mathbf{1-h}) \right)$$* The update of theta is also vectorized. Because the dimensions of $\mathbf{x}$ are (m, n+1), and both $\mathbf{h}$ and $\mathbf{y}$ are (m, 1), we need to transpose the $\mathbf{x}$ and place it on the left in order to perform matrix multiplication, which then yields the (n+1, 1) answer we need:$$\mathbf{\theta} = \mathbf{\theta} - \frac{\alpha}{m} \times \left( \mathbf{x}^T \cdot \left( \mathbf{h-y} \right) \right)$$ ###Code def gradientDescent(x, y, theta, alpha, num_iters): ''' Input: x: matrix of features which is (m,n+1) y: corresponding labels of the input matrix x, dimensions (m,1) theta: weight vector of dimension (n+1,1) alpha: learning rate num_iters: number of iterations you want to train your model for Output: J: the final cost theta: your final weight vector Hint: you might want to print the cost to make sure that it is going down. ''' ### START CODE HERE ### def _dot(x, y): return np.dot(x, y) def _log(x): return np.log(x) # get 'm', the number of rows in matrix x m = x.shape[0] for i in range(0, num_iters): # get z, the dot product of x and theta z = _dot(x, theta) # get the sigmoid of z h = sigmoid(z) # calculate the cost function J = -1/m * ( _dot( y.transpose(), _log(h) ) + _dot( (1-y).transpose(), _log(1-h) ) ) # update the weights theta theta -= alpha/m * _dot(x.transpose(), (h-y) ) ### END CODE HERE ### J = float(J) return J, theta ###Output _____no_output_____ ###Markdown Backpropagation Cross Entropy Softmax The softmax function has many roots. In physics, it is known as the Boltzmann or Gibbs distribution; in statistics, it’s multinomial logistic regression; and in the natural language processing (NLP) community it’s known as the maximum entropy (MaxEnt) 5 6 7 classifier. Weight Decay Momentum Convolution ###Code # ###Output _____no_output_____
Measurement parameters from Confusion Matrix - Reverse Engineering.ipynb
###Markdown Suggestion: If you observe that this jupyter notebook is not loading properply please follow these following steps: 1. Go to : https://nbviewer.jupyter.org/2. Here you will see a box, where it is writen "Enter the location of a Jupyter Notebook to have it rendered here:"3. Into that box, please paste the URL of this notebook.NB: you can copy the URL from the browser address bar, and then paste it there (step3) Purpose Sometimes it might happen that we considered only precision score from the computed model. We saved the confusion matrix for multiclass, and we have calculated the precision score. However, after some time, you might be needing to calculate the Recall, and F1 score from that confusion matrix. It is possible to calculate through the equations. You can easily see the description of precision, recall and F1 score from this link: https://en.wikipedia.org/wiki/Precision_and_recall. However, for multiclass classification, it is often very tough to back calculate all the things. So in this code, I have attempted to find out a way to calculate all the measurement paramters from the confusion matrix. You just need to provide the confusion matrix to the code, and it will calculate the rest for you. lets start ###Code import numpy as np # input the row of the predicted values cc = np.array([[48,1,0],[2,86,24],[4,36,181]]) # input the label names labels = ['Normal', 'Micro', 'Macro'] # you can put any size. # Here in this example we have put 3X3. You can use it for any dimenion, NXN, where N = 2 to your desired number # score calculate # recall score recall = np.diag(cc) / np.sum(cc, axis = 1) # axis 1 means column values print(recall) # mean of recall mr = np.mean(recall) print(mr) # precision score precision = np.diag(cc) / np.sum(cc, axis = 0) # axis 0 means row values print(precision) # mean of precision mr = np.mean(recall) print(mr) # F1 score F1 = 2 * (precision * recall) / (precision + recall) print(F1) # mean of F1 score mf = np.mean(F1) print(mf) # plot the confusion matrix # Plot function def plot_confusion_matrix(cm, target_names, title='Confusion matrix', cmap=None, normalize=True): import matplotlib.pyplot as plt import numpy as np import itertools accuracy = np.trace(cm) / float(np.sum(cm)) misclass = 1 - accuracy if cmap is None: cmap = plt.get_cmap('Blues') plt.figure(3) plt.figure(figsize=(8, 6)) plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() if target_names is not None: tick_marks = np.arange(len(target_names)) plt.xticks(tick_marks, target_names, rotation=45) plt.yticks(tick_marks, target_names) if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] thresh = cm.max() / 1.5 if normalize else cm.max() / 2 for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): if normalize: plt.text(j, i, "{:0.4f}".format(cm[i, j]), horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") else: plt.text(j, i, "{:,}".format(cm[i, j]), horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label\naccuracy={:0.4f}; misclass={:0.4f}'.format(accuracy, misclass)) plt.savefig('confusion_matrix.pdf', bbox_inches='tight') pass plot_confusion_matrix(cm = cc, normalize = False, target_names = labels, title = "Confusion Matrix for Dataset") ###Output _____no_output_____
spark.stream/sakarya_raw_tweets.ipynb
###Markdown TWITTER DUYGU ANALİZİ PROJESİ 1. APACHE SPARK KURULUMU ###Code !pip install findspark !pip install pymongo import pymongo myclient = pymongo.MongoClient( "mongodb://root:[email protected]:27017/") mydb = myclient["sakarya"] import findspark findspark.init("/usr/local/spark-3.2.0-bin-hadoop3.2") from pyspark.conf import SparkConf from pyspark import SparkContext from pyspark.sql import SparkSession from pyspark.sql import SQLContext from pyspark.sql.functions import * import html import numpy as np import json import matplotlib.pyplot as plt import pandas as pd import seaborn as sns pd.options.display.max_columns = None pd.options.display.max_rows = 250 pd.options.display.max_colwidth = 150 sns.set(color_codes=True) spark = SparkSession.builder\ .master("local[*]") \ .appName("ml") \ .config("spark.memory.fraction","0.8") \ .config("spark.executor.memory","8g") \ .config("spark.driver.memory","8g") \ .config("spark.sql.hive.filesourcePartitionFileCacheSize", "621440000") \ .config("spark.sql.sources.bucketing.maxBuckets", "100000") \ .config("spark.sql.shuffle.partitions", "2000") \ .config("spark.driver.maxResultSize","2g") \ .config("spark.shuffle.file.buffer","64k") \ .config("spark.scheduler.listenerbus.eventqueue.capacity", "1000") \ .config("spark.broadcast.blockSize", "8m") \ .config("spark.sql.autoBroadcastJoinThreshold", "-1") \ .getOrCreate() ###Output WARNING: An illegal reflective access operation has occurred WARNING: Illegal reflective access by org.apache.spark.unsafe.Platform (file:/usr/local/spark-3.2.0-bin-hadoop3.2/jars/spark-unsafe_2.12-3.2.0.jar) to constructor java.nio.DirectByteBuffer(long,int) WARNING: Please consider reporting this to the maintainers of org.apache.spark.unsafe.Platform WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations WARNING: All illegal access operations will be denied in a future release Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties Setting default log level to "WARN". To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel). 21/12/11 19:24:29 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable ###Markdown 2. EĞİTİM VERİSİNİN HAZIRLANMASI ###Code TRAIN_TWEET_PATH = "/home/jovyan/work/twitter_clients.csv" train_df = spark.read \ .option("header", True) \ .option("inferSchema", True) \ .option("sep", ",") \ .csv(TRAIN_TWEET_PATH).dropna() train_df=train_df.filter(~((train_df.emotionSegment != "1") & (train_df.emotionSegment != "0"))) train_df.count() from pyspark.sql.functions import col from pyspark.sql.types import StringType, IntegerType train_df = train_df.withColumn("createdAt",col("createdAt").cast(IntegerType())) \ .withColumn("emotionSegment",col("emotionSegment").cast(IntegerType())) \ .withColumn("likeCount",col("likeCount").cast(IntegerType())) \ .withColumn("name",col("name").cast(StringType())) \ .withColumn("quoteCount",col("quoteCount").cast(IntegerType())) \ .withColumn("replyCount",col("replyCount").cast(IntegerType())) \ .withColumn("retweetCount",col("retweetCount").cast(IntegerType())) \ .withColumn("text",col("text").cast(StringType())) train_df.printSchema() train_df = train_df.withColumn("original_text", f.col("text")) user_regex = r"(@\w{1,15})" hastag_regex = r"(#\w{1,})" url_regex = r"((https?|ftp|file):\/{2,3})+([-\w+&@#/%=~|$?!:,.]*)|(www.)+([-\w+&@#/%=~|$?!:,.]*)" email_regex = r"[\w.-]+@[\w.-]+\.[a-zA-Z]{1,}" train_df = ( train_df .withColumn("text", f.regexp_replace(f.col("text"), url_regex, "")) \ .withColumn("text", f.regexp_replace(f.col("text"), hastag_regex, "")) \ .withColumn("text", f.regexp_replace(f.col("text"), user_regex, "")) \ .withColumn("text", f.regexp_replace(f.col("text"), email_regex, "")) ) @f.udf def html_unescape(s: str): if isinstance(s, str): return html.unescape(s) return s train_df = train_df.withColumn("text", html_unescape(f.col("text"))) train_df.filter(f.col("text")=='').count() train_df = train_df.filter(~(f.col("text")=='')) train_df_clean = (train_df \ .withColumn("text", f.regexp_replace(f.col("text"), "[^a-zA-Z']", " ")) \ .withColumn("text", f.regexp_replace(f.col("text"), " +", " ")) \ .withColumn("text", f.trim(f.col("text")))) train_df_show = train_df_clean.sample(fraction=0.0001, seed=311564) train_df_show.toPandas().head(20) ###Output ###Markdown 3. MAKİNE ÖĞRENMESİ MODELİNİN HAZIRLANMASI ###Code %%time from pyspark.ml.feature import StopWordsRemover, Tokenizer, HashingTF, IDF from pyspark.ml.classification import LogisticRegression from pyspark.ml import Pipeline tokenizer = Tokenizer(inputCol="text", outputCol="words1") stopwords_remover = StopWordsRemover(inputCol="words1", outputCol="words2", stopWords=StopWordsRemover.loadDefaultStopWords("turkish")) hashing_tf = HashingTF(inputCol="words2", outputCol="term_frequency") idf = IDF(inputCol="term_frequency", outputCol="features", minDocFreq=5) lr = LogisticRegression(maxIter = 10, labelCol="emotionSegment", featuresCol="features") ###Output _____no_output_____ ###Markdown 4. MAKİNE ÖĞRENMESİ MODELİNİN EĞİTİLMESİ ###Code (trainingData, validationData, testData) = train_df_clean.randomSplit([0.6, 0.2, 0.2], seed=896) semantic_analysis = Pipeline( stages=[tokenizer, stopwords_remover, hashing_tf, idf, lr]) semantic_analysis_model = semantic_analysis.fit(train_df_clean) %%time trained_df = semantic_analysis_model.transform(trainingData) test_df = semantic_analysis_model.transform(testData) val_df = semantic_analysis_model.transform(validationData) ###Output CPU times: user 91.8 ms, sys: 28.2 ms, total: 120 ms Wall time: 650 ms ###Markdown 5. MAKİNE ÖĞRENMESİ MODELİNİN DEĞERLENDİRİLMESİ ###Code %%time from pyspark.ml.evaluation import MulticlassClassificationEvaluator from pyspark.ml.evaluation import BinaryClassificationEvaluator evaluator = MulticlassClassificationEvaluator( labelCol="emotionSegment", metricName="accuracy", predictionCol="prediction") accuracy_val = evaluator.evaluate(val_df) accuracy_test = evaluator.evaluate(test_df) print("Accuracy validationData: ", accuracy_val) print("Accuracy testData: ", accuracy_test) evaluator = MulticlassClassificationEvaluator( labelCol="emotionSegment", metricName="f1", predictionCol="prediction") f1_val = evaluator.evaluate(val_df) f1_test = evaluator.evaluate(test_df) print("f1 score validationData: ", f1_val) print("f1 score testData: ", f1_test) my_eval_lr = BinaryClassificationEvaluator(rawPredictionCol='prediction', labelCol='emotionSegment', metricName='areaUnderROC') roc_val = my_eval_lr.evaluate(val_df) roc_test = my_eval_lr.evaluate(test_df) print("roc_val score validationData: ", roc_val) print("roc_test score testData: ", roc_test) trainingData, validationData, testData val_df.columns val_df.groupBy('emotionSegment', 'prediction').count().show() TN = prediction.filter('prediction = 0 AND label = prediction').count() TP = prediction.filter('prediction = 1 AND label = prediction').count() FN = prediction.filter('prediction = 0 AND label != prediction').count() FP = prediction.filter('prediction = 1 AND label != prediction').count() accuracy = (TN + TP) / (TN + TP + FN + FP) confusion_tablo = val_df.groupBy('emotionSegment', 'prediction').count().toPandas() confusion_tablo true_positive = confusion_tablo["count"][0] true_negative = confusion_tablo["count"][3] false_negative = confusion_tablo["count"][1] false_positive = confusion_tablo["count"][2] arr = np.empty((2,2)) arr[0][0] = true_negative arr[0][1] = false_positive arr[1][0] = false_negative arr[1][1] = true_positive int(true_positive/(true_positive+false_positive)*100) int(true_negative/(false_negative+true_negative)*100) int((false_negative/(false_negative+true_negative))*100) int(false_positive/(true_positive+false_positive)*100) ErrorRate = (false_negative + false_positive) / (true_positive + true_negative + false_negative + false_positive) SensivityRate = true_positive/(false_negative + true_positive) SpecifityRate = true_negative/(true_negative + false_positive) PrecisionRate = true_positive/(false_positive+true_positive) PrevalenceRate = (false_negative+true_positive) / (false_negative+true_positive+true_negative+false_positive) RecalRate = true_positive/(true_positive+false_negative) print(ErrorRate) print(SensivityRate) print(SpecifityRate) print(PrecisionRate) print(PrevalenceRate) print(RecalRate) fig, ax = plt.subplots(figsize=(10,10)) sns.heatmap(arr, annot=True, linewidths=.5, ax=ax, fmt="g") api_info_model = {"TypeKey":"TwitterApi", "TotalRequestLimit":0, "RemainingRequest":0, "MlResultAccuracyRate":accuracy_val*100, "MlResultF1Rate":f1_val*100,"MlResultROCRate":roc_val*100, "true_positive":166969,"true_negative":155888, "false_negative":50379,"false_positive":52438, "ErrorRate":24,"SensivityRate":76, "SpecifityRate":74,"PrecisionRate":76, "PrevalenceRate":51,"RecalRate":76, "MachineLearningModelName":"LogisticRegression"} mycol = mydb["ApiInfoModel"] mycol.insert_one(api_info_model) ###Output _____no_output_____ ###Markdown 6. EĞİTİLMİŞ MODELİN KAYIT EDİLMESİ ###Code semantic_analysis_model.save("lr_sakarya_twitter_sentiment_analysis_model.pkl") ###Output 21/12/11 19:34:19 WARN TaskSetManager: Stage 28 contains a task of very large size (4184 KiB). The maximum recommended task size is 1000 KiB. 21/12/11 19:34:21 WARN TaskSetManager: Stage 32 contains a task of very large size (1496 KiB). The maximum recommended task size is 1000 KiB. ###Markdown SAKARYA ÜNİVERSİTESİYLE İLGİLİ TWEETLERİN DUYGU ANALİZİNİN YAPILMASI 1. EĞİTİLMİŞ MODELİN YÜKLENMESİ ###Code from pyspark.ml import PipelineModel MODEL_PATH = "/home/jovyan/work/model/lr_sakarya_twitter_sentiment_analysis_model.pkl" sentiment_model = PipelineModel.load(MODEL_PATH) ###Output _____no_output_____ ###Markdown 2. SAKARYA ÜNİVERSİTESİYLE İLGİLİ TWEETLERİN DATAFRAME HALİNE ÇEVİRİLMESİ ###Code SAKARYA_TWEET_PATH = "/home/jovyan/work/sakarya_student_tweets2.csv" sakarya_tweet_df = spark.read \ .option("header", True) \ .option("inferSchema", True) \ .option("sep", ",") \ .csv(SAKARYA_TWEET_PATH).dropna() sakarya_tweet_df.limit(20).toPandas().head() sakarya_tweet_df.count() ###Output ###Markdown 3. SAKARYA ÜNİVERSİTESİYLE İLGİLİ TWEETLERİN HAZIRLANMASI ###Code sakarya_tweet_df = sakarya_tweet_df.withColumn("createdAt",col("createdAt").cast(IntegerType())) \ .withColumn("likeCount",col("likeCount").cast(IntegerType())) \ .withColumn("name",col("name").cast(StringType())) \ .withColumn("quoteCount",col("quoteCount").cast(IntegerType())) \ .withColumn("replyCount",col("replyCount").cast(IntegerType())) \ .withColumn("retweetCount",col("retweetCount").cast(IntegerType())) \ .withColumn("text",col("text").cast(StringType())) sakarya_tweet_df.printSchema() sakarya_tweet_df = sakarya_tweet_df.withColumn("original_text", f.col("text")) user_regex = r"(@\w{1,15})" hastag_regex = r"(#\w{1,})" url_regex = r"((https?|ftp|file):\/{2,3})+([-\w+&@#/%=~|$?!:,.]*)|(www.)+([-\w+&@#/%=~|$?!:,.]*)" email_regex = r"[\w.-]+@[\w.-]+\.[a-zA-Z]{1,}" sakarya_tweet_df = ( sakarya_tweet_df .withColumn("text", f.regexp_replace(f.col("text"), url_regex, "")) \ .withColumn("text", f.regexp_replace(f.col("text"), hastag_regex, "")) \ .withColumn("text", f.regexp_replace(f.col("text"), user_regex, "")) \ .withColumn("text", f.regexp_replace(f.col("text"), email_regex, "")) ) import html @f.udf def html_unescape(s: str): if isinstance(s, str): return html.unescape(s) return s sakarya_tweet_df = sakarya_tweet_df.withColumn("text", html_unescape(f.col("text"))) sakarya_tweet_df.filter(f.col("text")=='').count() sakarya_tweet_df = sakarya_tweet_df.filter(~(f.col("text")=='')) sakarya_tweet_df_clean = (sakarya_tweet_df \ .withColumn("text", f.regexp_replace(f.col("text"), "[^a-zA-Z']", " ")) \ .withColumn("text", f.regexp_replace(f.col("text"), " +", " ")) \ .withColumn("text", f.trim(f.col("text")))) sakarya_tweet_df_clean.show(4) ###Output +---------+---------+------+----------+----------+------------+--------------------+--------------------+ |createdAt|likeCount| name|quoteCount|replyCount|retweetCount| text| original_text| +---------+---------+------+----------+----------+------------+--------------------+--------------------+ | 20211207| 1|sau***| 0| 0| 0| A Piece of Paradise|A Piece of Paradise.| | 20211207| 0|mka***| 0| 0| 0|bol bol g k'y z n...|bol bol gök'yüzün...| | 20211207| 34|Muf***| 0| 1| 7|Haftaya konu umuz...|Haftaya konuğumuz...| | 20211207| 0|ADA***| 0| 0| 0|Afrikal rencilerd...|Afrikalı Öğrencil...| +---------+---------+------+----------+----------+------------+--------------------+--------------------+ only showing top 4 rows ###Markdown 4. SAKARYA ÜNİVERSİTESİYLE İLGİLİ TWEETLERİN DUYGU ANALİZİ YAPILMASI ###Code raw_sentiment = sentiment_model.transform(sakarya_tweet_df_clean) sentiment = raw_sentiment.select( "createdAt", "likeCount", "name", "quoteCount","replyCount", "retweetCount" ,"text", "original_text", f.col("prediction").alias("user_sentiment") ) sentiment.limit(100).toPandas().head(100) ###Output 21/12/11 19:49:28 WARN DAGScheduler: Broadcasting large task binary with size 5.5 MiB Traceback (most recent call last): File "/usr/local/spark-3.2.0-bin-hadoop3.2/python/lib/pyspark.zip/pyspark/daemon.py", line 186, in manager File "/usr/local/spark-3.2.0-bin-hadoop3.2/python/lib/pyspark.zip/pyspark/daemon.py", line 74, in worker File "/usr/local/spark-3.2.0-bin-hadoop3.2/python/lib/pyspark.zip/pyspark/worker.py", line 663, in main if read_int(infile) == SpecialLengths.END_OF_STREAM: File "/usr/local/spark-3.2.0-bin-hadoop3.2/python/lib/pyspark.zip/pyspark/serializers.py", line 564, in read_int raise EOFError EOFError ###Markdown 5. SAKARYA DUYGU ANALİZİNİN GRAFİĞE DÖNÜŞTÜRÜLMESİ ###Code sentiment.groupBy("user_sentiment").count().toPandas() graph_data = sentiment.groupBy("user_sentiment").count().toPandas() sns.barplot(x = graph_data["user_sentiment"].values, y = graph_data["count"].values) ###Output _____no_output_____ ###Markdown 6. MongoDb VERİTABANINA VERİNİN KAYIT EDİLMESİ ###Code results = sentiment.toJSON().map(lambda j: json.loads(j)).collect() print(results[0]) mycol = mydb["twitter_sentiment"] mycol.insert_many(results) ###Output _____no_output_____ ###Markdown 6. SPARK OTURUMUNUN SONLANDIRILMASI ###Code spark.stop() ###Output _____no_output_____
docs/src/notebooks/non-interactive/projected_spectral_as_subplots.ipynb
###Markdown Projected bandstructures/DOS as subplots with custom colours This example notebook provides a recipe/hack to get projectors as subplots. This functionality is not wrapped into the `dispersion` script (as of Aug 2020) as the whole module needs refactoring first. These examples assume some spectral files with the seedname "Si" in the current directory. ###Code from matador.plotting.spectral_plotting import dispersion_plot, dos_plot import matplotlib.pyplot as plt %matplotlib inline fig, axes = plt.subplots(1, 2, figsize=(10, 5), sharey=True) colours_override = ["firebrick", "darkorchid"] for ind, proj in enumerate([[("Si", "s", None)], [("Si", "p", None)]]): dispersion_kwargs = { "projectors_to_plot": proj, "plot_pdis": True, "pdis_interpolation_factor": 10, "colours": [colours_override[ind]], "colour_cycle": [colours_override[ind]] } dispersion_plot( "Si", axes[ind], dispersion_kwargs ) axes[1].set_ylabel(None) plt.tight_layout() ###Output Detected path labels from cell file Detected path labels from cell file ###Markdown We can also do the same with density of states plots. Note here, the PDOS is from a different structure and calculation to the total DOS, and is shown only for ilustrative purposes. ###Code fig, axes = plt.subplots(2, 1, figsize=(12, 8), sharex=True) colours_override = ["dodgerblue", "gold", "magenta", "olive"] for ind, proj in enumerate([[("K", "s", None), ("K", "p", None)], [("P", "s", None), ("P", "p", None)]]): dos_kwargs = { "projectors_to_plot": proj, "colours": colours_override[2*ind:], "pdos_hide_sum": True, "plot_pdos": True } dos_plot("Si", axes[ind], dos_kwargs) axes[0].set_xlabel(None) plt.tight_layout() ###Output _____no_output_____
python-scripts/data_analytics_learn/link_pandas/Ex_Files_Pandas_Data/Exercise Files/05_02/Begin/Figures.ipynb
###Markdown Figures and Subplots- figure - container thats holds all elements of plot(s)- subplot - appears within a rectangular grid within a figure ###Code import pandas as pd import numpy as np import matplotlib.pyplot as plt plt.style.use('ggplot') my_first_figure = plt.figure("My First Figure") subplot_1 = my_first_figure.add_subplot(2, 3, 1) subplot_6 = my_first_figure.add_subplot(2, 3, 6) plt.plot(np.random.rand(50).cumsum(), 'k--') plt.show() subplot_2 = my_first_figure.add_subplot(2, 3, 2) plt.plot(np.random.rand(50), 'go') subplot_6 plt.show() ###Output _____no_output_____
tensorflow/chapter_preliminaries/probability.ipynb
###Markdown 概率:label:`sec_prob`简单地说,机器学习就是做出预测。根据病人的临床病史,我们可能想预测他们在下一年心脏病发作的*概率*。在飞机喷气发动机的异常检测中,我们想要评估一组发动机读数为正常运行情况的概率有多大。在强化学习中,我们希望智能体(agent)能在一个环境中智能地行动。这意味着我们需要考虑在每种可行的行为下获得高奖励的概率。当我们建立推荐系统时,我们也需要考虑概率。例如,假设我们为一家大型在线书店工作,我们可能希望估计某些用户购买特定图书的概率。为此,我们需要使用概率学。有完整的课程、专业、论文、职业、甚至院系,都致力于概率学的工作。所以很自然地,我们在这部分的目标不是教授你整个科目。相反,我们希望教给你在基础的概率知识,使你能够开始构建你的第一个深度学习模型,以便你可以开始自己探索它。现在让我们更认真地考虑第一个例子:根据照片区分猫和狗。这听起来可能很简单,但对于机器却可能是一个艰巨的挑战。首先,问题的难度可能取决于图像的分辨率。![不同分辨率的图像 ($10 \times 10$, $20 \times 20$, $40 \times 40$, $80 \times 80$, 和 $160 \times 160$ pixels)](../img/cat-dog-pixels.png):width:`300px`:label:`fig_cat_dog`如 :numref:`fig_cat_dog`所示,虽然人类很容易以$160 \times 160$像素的分辨率识别猫和狗,但它在$40\times40$像素上变得具有挑战性,而且在$10 \times 10$像素下几乎是不可能的。换句话说,我们在很远的距离(从而降低分辨率)区分猫和狗的能力可能会变为猜测。概率给了我们一种正式的途径来说明我们的确定性水平。如果我们完全肯定图像是一只猫,我们说标签$y$是"猫"的*概率*,表示为$P(y=$"猫"$)$等于$1$。如果我们没有证据表明$y=$“猫”或$y=$“狗”,那么我们可以说这两种可能性是相等的,即$P(y=$"猫"$)=P(y=$"狗"$)=0.5$。如果我们不十分确定图像描绘的是一只猫,我们可以将概率赋值为$0.5<P(y=$"猫"$)<1$。现在考虑第二个例子:给出一些天气监测数据,我们想预测明天北京下雨的概率。如果是夏天,下雨的概率是0.5。在这两种情况下,我们都不确定结果,但这两种情况之间有一个关键区别。在第一种情况中,图像实际上是狗或猫二选一。在第二种情况下,结果实际上是一个随机的事件。因此,概率是一种灵活的语言,用于说明我们的确定程度,并且它可以有效地应用于广泛的领域中。 基本概率论假设我们掷骰子,想知道看到1的几率有多大,而不是看到另一个数字。如果骰子是公平的,那么所有六个结果$\{1, \ldots, 6\}$都有相同的可能发生,因此我们可以说$1$发生的概率为$\frac{1}{6}$。然而现实生活中,对于我们从工厂收到的真实骰子,我们需要检查它是否有瑕疵。检查骰子的唯一方法是多次投掷并记录结果。对于每个骰子,我们将观察到$\{1, \ldots, 6\}$中的一个值。对于每个值,一种自然的方法是将它出现的次数除以投掷的总次数,即此*事件*(event)概率的*估计值*。*大数定律*(law of large numbers)告诉我们:随着投掷次数的增加,这个估计值会越来越接近真实的潜在概率。让我们用代码试一试!首先,我们导入必要的软件包。 ###Code %matplotlib inline import numpy as np import tensorflow as tf import tensorflow_probability as tfp from d2l import tensorflow as d2l ###Output _____no_output_____ ###Markdown 在统计学中,我们把从概率分布中抽取样本的过程称为*抽样*(sampling)。笼统来说,可以把*分布*(distribution)看作是对事件的概率分配,稍后我们将给出的更正式定义。将概率分配给一些离散选择的分布称为*多项分布*(multinomial distribution)。为了抽取一个样本,即掷骰子,我们只需传入一个概率向量。输出是另一个相同长度的向量:它在索引$i$处的值是采样结果中$i$出现的次数。 ###Code fair_probs = tf.ones(6) / 6 tfp.distributions.Multinomial(1, fair_probs).sample() ###Output _____no_output_____ ###Markdown 在估计一个骰子的公平性时,我们希望从同一分布中生成多个样本。如果用Python的for循环来完成这个任务,速度会慢得惊人。因此我们使用深度学习框架的函数同时抽取多个样本,得到我们想要的任意形状的独立样本数组。 ###Code tfp.distributions.Multinomial(10, fair_probs).sample() ###Output _____no_output_____ ###Markdown 现在我们知道如何对骰子进行采样,我们可以模拟1000次投掷。然后,我们可以统计1000次投掷后,每个数字被投中了多少次。具体来说,我们计算相对频率,以作为真实概率的估计。 ###Code counts = tfp.distributions.Multinomial(1000, fair_probs).sample() counts / 1000 ###Output _____no_output_____ ###Markdown 因为我们是从一个公平的骰子中生成的数据,我们知道每个结果都有真实的概率$\frac{1}{6}$,大约是$0.167$,所以上面输出的估计值看起来不错。我们也可以看到这些概率如何随着时间的推移收敛到真实概率。让我们进行500组实验,每组抽取10个样本。 ###Code counts = tfp.distributions.Multinomial(10, fair_probs).sample(500) cum_counts = tf.cumsum(counts, axis=0) estimates = cum_counts / tf.reduce_sum(cum_counts, axis=1, keepdims=True) d2l.set_figsize((6, 4.5)) for i in range(6): d2l.plt.plot(estimates[:, i].numpy(), label=("P(die=" + str(i + 1) + ")")) d2l.plt.axhline(y=0.167, color='black', linestyle='dashed') d2l.plt.gca().set_xlabel('Groups of experiments') d2l.plt.gca().set_ylabel('Estimated probability') d2l.plt.legend(); ###Output _____no_output_____
1_mosaic_data_attention_experiments/3_stage_wise_training/alternate_minimization/effect on interpretability/type4_with_sparse_regulariser/10runs_entropy_001_every10_where_what.ipynb
###Markdown **Focus Net** ###Code class Module1(nn.Module): def __init__(self): super(Module1, self).__init__() self.fc1 = nn.Linear(2, 100) self.fc2 = nn.Linear(100, 1) def forward(self, z): x = torch.zeros([batch,9],dtype=torch.float64) y = torch.zeros([batch,2], dtype=torch.float64) x,y = x.to("cuda"),y.to("cuda") for i in range(9): x[:,i] = self.helper(z[:,i])[:,0] log_x = F.log_softmax(x,dim=1) x = F.softmax(x,dim=1) # alphas for i in range(9): x1 = x[:,i] y = y + torch.mul(x1[:,None],z[:,i]) return y , x , log_x def helper(self,x): x = F.relu(self.fc1(x)) x = self.fc2(x) return x ###Output _____no_output_____ ###Markdown **Classification Net** ###Code class Module2(nn.Module): def __init__(self): super(Module2, self).__init__() self.fc1 = nn.Linear(2, 100) self.fc2 = nn.Linear(100, 3) def forward(self,y): y = F.relu(self.fc1(y)) y = self.fc2(y) return y criterion = nn.CrossEntropyLoss() def my_cross_entropy(x, y,alpha,log_alpha,k): # log_prob = -1.0 * F.log_softmax(x, 1) # loss = log_prob.gather(1, y.unsqueeze(1)) # loss = loss.mean() loss = criterion(x,y) #alpha = torch.clamp(alpha,min=1e-10) b = -1.0* alpha * log_alpha b = torch.mean(torch.sum(b,dim=1)) closs = loss entropy = b loss = (1-k)*loss + ((k)*b) return loss,closs,entropy ###Output _____no_output_____ ###Markdown ###Code def calculate_attn_loss(dataloader,what,where,criter,k): what.eval() where.eval() r_loss = 0 cc_loss = 0 cc_entropy = 0 alphas = [] lbls = [] pred = [] fidices = [] with torch.no_grad(): for i, data in enumerate(dataloader, 0): inputs, labels,fidx = data lbls.append(labels) fidices.append(fidx) inputs = inputs.double() inputs, labels = inputs.to("cuda"),labels.to("cuda") avg,alpha,log_alpha = where(inputs) outputs = what(avg) _, predicted = torch.max(outputs.data, 1) pred.append(predicted.cpu().numpy()) alphas.append(alpha.cpu().numpy()) #ent = np.sum(entropy(alpha.cpu().detach().numpy(), base=2, axis=1))/batch # mx,_ = torch.max(alpha,1) # entropy = np.mean(-np.log2(mx.cpu().detach().numpy())) # print("entropy of batch", entropy) #loss = (1-k)*criter(outputs, labels) + k*ent loss,closs,entropy = my_cross_entropy(outputs,labels,alpha,log_alpha,k) r_loss += loss.item() cc_loss += closs.item() cc_entropy += entropy.item() alphas = np.concatenate(alphas,axis=0) pred = np.concatenate(pred,axis=0) lbls = np.concatenate(lbls,axis=0) fidices = np.concatenate(fidices,axis=0) #print(alphas.shape,pred.shape,lbls.shape,fidices.shape) analysis = analyse_data(alphas,lbls,pred,fidices) return r_loss/i,cc_loss/i,cc_entropy/i,analysis def analyse_data(alphas,lbls,predicted,f_idx): ''' analysis data is created here ''' batch = len(predicted) amth,alth,ftpt,ffpt,ftpf,ffpf = 0,0,0,0,0,0 for j in range (batch): focus = np.argmax(alphas[j]) if(alphas[j][focus] >= 0.5): amth +=1 else: alth +=1 if(focus == f_idx[j] and predicted[j] == lbls[j]): ftpt += 1 elif(focus != f_idx[j] and predicted[j] == lbls[j]): ffpt +=1 elif(focus == f_idx[j] and predicted[j] != lbls[j]): ftpf +=1 elif(focus != f_idx[j] and predicted[j] != lbls[j]): ffpf +=1 #print(sum(predicted==lbls),ftpt+ffpt) return [ftpt,ffpt,ftpf,ffpf,amth,alth] number_runs = 10 full_analysis =[] FTPT_analysis = pd.DataFrame(columns = ["FTPT","FFPT", "FTPF","FFPF"]) k = 0.001 every_what_epoch = 10 for n in range(number_runs): print("--"*40) # instantiate focus and classification Model torch.manual_seed(n) where = Module1().double() torch.manual_seed(n) what = Module2().double() where = where.to("cuda") what = what.to("cuda") # instantiate optimizer optimizer_where = optim.Adam(where.parameters(),lr =0.001) optimizer_what = optim.Adam(what.parameters(), lr=0.001) #criterion = nn.CrossEntropyLoss() acti = [] analysis_data = [] loss_curi = [] epochs = 1000 # calculate zeroth epoch loss and FTPT values running_loss ,_,_,anlys_data= calculate_attn_loss(train_loader,what,where,criterion,k) loss_curi.append(running_loss) analysis_data.append(anlys_data) print('epoch: [%d ] loss: %.3f' %(0,running_loss)) # training starts for epoch in range(epochs): # loop over the dataset multiple times ep_lossi = [] running_loss = 0.0 what.train() where.train() if ((epoch) % (every_what_epoch*2) ) <= every_what_epoch-1 : print(epoch+1,"updating where_net, what_net is freezed") print("--"*40) elif ((epoch) % (every_what_epoch*2)) > every_what_epoch-1 : print(epoch+1,"updating what_net, where_net is freezed") print("--"*40) for i, data in enumerate(train_loader, 0): # get the inputs inputs, labels,_ = data inputs = inputs.double() inputs, labels = inputs.to("cuda"),labels.to("cuda") # zero the parameter gradients optimizer_where.zero_grad() optimizer_what.zero_grad() # forward + backward + optimize avg, alpha,log_alpha = where(inputs) outputs = what(avg) my_loss,_,_ = my_cross_entropy(outputs,labels,alpha,log_alpha,k) # print statistics running_loss += my_loss.item() my_loss.backward() if ((epoch) % (every_what_epoch*2) ) <= every_what_epoch-1 : optimizer_where.step() elif ( (epoch) % (every_what_epoch*2)) > every_what_epoch-1 : optimizer_what.step() # optimizer_where.step() # optimizer_what.step() #break running_loss,ccloss,ccentropy,anls_data = calculate_attn_loss(train_loader,what,where,criterion,k) analysis_data.append(anls_data) print('epoch: [%d] loss: %.3f celoss: %.3f entropy: %.3f' %(epoch + 1,running_loss,ccloss,ccentropy)) loss_curi.append(running_loss) #loss per epoch if running_loss<=0.005: break print('Finished Training run ' +str(n)) #break analysis_data = np.array(analysis_data) FTPT_analysis.loc[n] = analysis_data[-1,:4]/30 full_analysis.append((epoch, analysis_data)) correct = 0 total = 0 with torch.no_grad(): for data in train_loader: images, labels,_ = data images = images.double() images, labels = images.to("cuda"), labels.to("cuda") avg, alpha,log_alpha = where(images) outputs = what(avg) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the 3000 train images: %d %%' % ( 100 * correct / total)) a,b= full_analysis[0] print(a) cnt=1 for epoch, analysis_data in full_analysis: analysis_data = np.array(analysis_data) # print("="*20+"run ",cnt,"="*20) plt.figure(figsize=(6,6)) plt.plot(np.arange(0,epoch+2,1),analysis_data[:,0],label="ftpt") plt.plot(np.arange(0,epoch+2,1),analysis_data[:,1],label="ffpt") plt.plot(np.arange(0,epoch+2,1),analysis_data[:,2],label="ftpf") plt.plot(np.arange(0,epoch+2,1),analysis_data[:,3],label="ffpf") plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) plt.title("Training trends for run "+str(cnt)) plt.savefig(path+"where_what/every10/run"+str(cnt)+".png",bbox_inches="tight") plt.savefig(path+"where_what/every10/run"+str(cnt)+".pdf",bbox_inches="tight") cnt+=1 np.mean(np.array(FTPT_analysis),axis=0) #array([87.85333333, 5.92 , 0. , 6.22666667]) FTPT_analysis.to_csv(path+"where_what/FTPT_analysis_every10.csv",index=False) FTPT_analysis ###Output _____no_output_____
Programacao_Linear_pacote_pulp_ALUNA_O.ipynb
###Markdown ###Code # Instalar a biblioteca pulp # importar a bilblioteca pulp %pip install pulp from pulp import * # Definir um nome para o problema e especificar o que quero fazer: maximizar o lucro model = LpProblem('Teste_maximo',LpMaximize) # Definir as variáveis de decisão x =LpVariable('x',lowBound=0) y =LpVariable('y',lowBound=0) # definir a função objetivo do problema em questão # função objetivo model += 5*x + 4*y # definir as restrições do problema model += 6*x + 4*y <= 24 # 1a restrição model += x + 2*y <= 6 # 2a restrição # Comando para resolver a programação linear - fç objetivo com as restrições status = model.solve() # nome_da_fç.solve() - comando para resolver o problema print(model) print('Otimo valor de x: ',value(x)) print('Otimo valor de y: ',value(y)) print('Resultado da função objetivo: ',value(model.objective)) print('Qual é o estatus do problema: ',LpStatus[status]) ###Output _____no_output_____ ###Markdown - ATIVIDADE Programação Linear - pulp Quero maximar uma função objetivo - Quero obter lucro máximo em uma atividade. max Lucro = 200 * x1 + 300 * x2 subject - s.a (sujeito a): restrições x1 + x2 <= 45 (área) 3 * x1 + x2 <= 100 (empregados) 2 * x1 + 4 * x2 <= 120 (fertilizante) * x1 = quantidade de milho; x2 = quantidade de feijão* área de plantão* número de total de trabalhadores no campo* quantidade disponível de fertizante para o plantioResposta: x1 = 20x2 = 20Lucro Máximo = 10000 ###Code ###Output _____no_output_____
algorithms/trees/traversals.ipynb
###Markdown Traversals ###Code class Node: def __init__(self, value, left=None, right=None): self.value = value self.left = left self.right = right head = Node( value="A", left=Node( value="B", left=Node( value="D", left=Node(value="H"), right=Node(value="I"), ), right=Node(value="E"), ), right=Node( value="C", left=Node(value="F"), right=Node( value="G", left=Node(value="J") ), ), ) ###Output _____no_output_____ ###Markdown Pre-order ###Code def preorder_traversal(node): stack = [] if node: stack.append(node.value) stack = stack + preorder_traversal(node.left) stack = stack + preorder_traversal(node.right) return stack preorder_traversal(head) ###Output _____no_output_____ ###Markdown In-order ###Code def inorder_traversal(node): stack = [] if node: stack = inorder_traversal(node.left) stack.append(node.value) stack = stack + inorder_traversal(node.right) return stack inorder_traversal(head) ###Output _____no_output_____ ###Markdown Post-order ###Code def postorder_traversal(node): stack = [] if node: stack = postorder_traversal(node.left) stack = stack + postorder_traversal(node.right) stack.append(node.value) return stack postorder_traversal(head) ###Output _____no_output_____
netflix-amazonprime-disney-hoststar-recom-system.ipynb
###Markdown Here we will be building content based recommendation system for movies and web shows on 3 OTT platforms viz: Netflix,Amazon Prime and Disney+ Hotstar.As these are most popular OTT platforms worldwide, one might stuck on what to watch on them. Loading Datasets ###Code # Load netflix data netflix = pd.read_csv("/kaggle/input/netflix-shows/netflix_titles.csv") netflix.head() netflix.shape # Load Amazon Prime Data amznprime = pd.read_csv("/kaggle/input/amazon-prime-movies-and-tv-shows/amazon_prime_titles.csv") amznprime.head() amznprime.shape hotstar = pd.read_csv("/kaggle/input/disney-movies-and-tv-shows/disney_plus_titles.csv") hotstar.head() hotstar.shape ###Output _____no_output_____ ###Markdown We now concatinate all three dataframes as we are building combined recommendation system.* column "show id" is common in all dataframes, we will drop it * In final dataframe we want information about on which platform recommended shows are available* We will add one column naming "platform" in all dataframes,for example :- **netflix['platform']** containing all values as "Netflix" ###Code # Dropping "show_id" column netflix.drop("show_id", axis=1, inplace=True) amznprime.drop("show_id",axis=1, inplace=True) hotstar.drop("show_id", axis=1, inplace=True) # adding "platform" column to respective dataframe netflix['platform'] = "Netflix" amznprime['platform'] = "Amazon Prime" hotstar['platform'] = "Disney+ Hotstar" ## creating final Dataframe df = pd.concat([netflix, amznprime, hotstar], ignore_index=True) df.shape df.tail() ###Output _____no_output_____ ###Markdown Analysis of final Dataframe ###Code # Type of content available df.type.unique() # misssing values df.isnull().sum() df.info() # we need to create new Data frame according to features required for recommendation newdf = df.drop('rating', axis=1) newdf.head() dropped_nan = df.dropna() dropped_nan.shape ###Output _____no_output_____ ###Markdown We have large number of entries with missing valuesdropping them will result in loss of information ###Code # removing spaces between individual terms in entries # for ex "" newdf['director']=newdf['director'].apply(lambda x: str(x).replace(" ","")) newdf['cast']=newdf['cast'].apply(lambda x: str(x).replace(" ","")) newdf['country']=newdf['country'].apply(lambda x: str(x).replace(" ","")) newdf['listed_in']=newdf['listed_in'].apply(lambda x: str(x).replace(" ","")) newdf['type']=newdf['type'].apply(lambda x: str(x).replace(" ","")) # creating list of words in each string available in 'description' column newdf['description']=newdf['description'].apply(lambda x:x.split()) # converting all rows to list newdf['type']=newdf['type'].apply(lambda x:list(x.split(" "))) newdf['listed_in']=newdf['listed_in'].apply(lambda x:list(x.split(" "))) newdf['director'] = newdf['director'].apply(lambda x:list(x.split(" "))) newdf['cast'] = newdf['cast'].apply(lambda x:list(x.split(" "))) newdf['country'] = newdf['country'].apply(lambda x:list(x.split(" "))) newdf['release_year'] =newdf['release_year'].apply(lambda x:list(str(x).split(" "))) # creating new column for tags newdf['tags'] = newdf['type']+newdf['director']+newdf['cast']+newdf['country']+newdf['release_year']+newdf['listed_in']+newdf['description'] # we have lot of entries with "nan" values, remove those values from tag list for row in newdf['tags']: if "nan" in row: row.remove("nan") # to form vectors we need strings, so convert list of tags to string newdf['tags']=newdf['tags'].apply(lambda x:" ".join(x)) from sklearn.feature_extraction.text import TfidfVectorizer # create instance of TFIDF vectorizer with stopwords in "english" language #so that vectors will be formed without frequent stopwords tv = TfidfVectorizer(max_features=30000,stop_words="english") # create vectors and storing them into array vectors = tv.fit_transform(newdf['tags']).toarray() vectors.shape from sklearn.metrics.pairwise import cosine_similarity similarity = cosine_similarity(vectors) similarity dis=sorted(list(enumerate(similarity[0])), reverse=True, key=lambda x:x[1]) dis[1:6] #newdf[newdf['title'] == "Ganglands"].index # above code gives tuple => Int64Index([2], dtype='int64') # we jusst want index [2] to be fetched, in 0th position in tuple newdf[newdf['title'] == "Ganglands"].index[0] # define recommend function def recommend(movie): index = newdf[newdf['title'] == movie].index[0] distances = sorted(list(enumerate(similarity[index])), reverse=True,key=lambda x:x[1]) #for i in distances[1:6]: #print(newdf.iloc[i[0]].title) #print("Watch on:- ",newdf.iloc[i[0]].platform) dic = {0: df.iloc[distances[1][0]], 1: df.iloc[distances[2][0]], 2: df.iloc[distances[3][0]], 3: df.iloc[distances[4][0]], 4: df.iloc[distances[5][0]]} df1 = pd.DataFrame(dic).T return df1 recommend("Kota Factory") ###Output _____no_output_____
notebooks/complete/07_Loading-data.ipynb
###Markdown Read a text file of data using `numpy.loadtxt`* Numpy provides the function loadtxt to read and parse numeric data from a text file.* The file can be delimited with commas (a 'comma separated file'), tabs, or other common delimiters* Numerical data can be converted to floating point data or integers* Headers and comments can be ignored during the reading of the file. ###Code !cat data/galileo_flat.txt data = numpy.loadtxt('data/galileo_flat.txt') print("data is ", data) print("data shape is ", data.shape) ###Output data is [[1500. 1000.] [1340. 828.] [1328. 800.] [1172. 600.] [ 800. 300.]] data shape is (5, 2) ###Markdown Read a comma separated file of data with headers using keywords* If you have a delimiter in your file (a comma, tab, vertical line), specify that with the `delimiter` keyword.* If you use a comment character consistently, using the `comments` keyword.* If you have a header you want to skip, use `skiprows` ###Code !cat data/galileo_flat.csv data = numpy.loadtxt('data/galileo_flat.csv', comments="#", skiprows=2, delimiter=',') print(data) ###Output [[1500. 1000.] [1340. 828.] [1328. 800.] [1172. 600.] [ 800. 300.]] ###Markdown * Because the header lines are commented, I don't need `skiprows`.* Because I used the pound sign for a comment, I don't need the `comments` keyword. ###Code data = numpy.loadtxt('data/galileo_flat.csv', delimiter=',') print(data) ###Output [[1500. 1000.] [1340. 828.] [1328. 800.] [1172. 600.] [ 800. 300.]] ###Markdown Remember your data has the shape `ROWS X COLUMNS`* Your data will be shaped with the rows first.* You can change the order with transpose ###Code print("data shape is ",data.shape) ###Output data shape is (5, 2) ###Markdown Split the data into variables using the `unpack` keyword ###Code D,H = numpy.loadtxt('data/galileo_flat.csv', delimiter=',',unpack=True) print(D,H) print("D shape is ",D.shape) print("H shape is ",H.shape) #equivalent code data = numpy.loadtxt('data/galileo_flat.csv', delimiter=',') #transpose the array to columns x rows D,H = data.T print(D,H) print("D shape is ",D.shape) print("H shape is ",H.shape) ###Output [1500. 1340. 1328. 1172. 800.] [1000. 828. 800. 600. 300.] D shape is (5,) H shape is (5,) ###Markdown Save data with `numpy.savetxt` ###Code numpy.savetxt("data/mydata.txt", data, delimiter=',') !cat data/mydata.txt ###Output 1.500000000000000000e+03,1.000000000000000000e+03 1.340000000000000000e+03,8.280000000000000000e+02 1.328000000000000000e+03,8.000000000000000000e+02 1.172000000000000000e+03,6.000000000000000000e+02 8.000000000000000000e+02,3.000000000000000000e+02 ###Markdown Control the data format with the `fmt` keyword* The default format for the data is floating point data with many digits* You can change the format with the `fmt` keyword ###Code numpy.savetxt("data/mydata2.txt", data,delimiter=',', fmt='%.6g') !cat data/mydata2.txt ###Output 1500,1000 1340,828 1328,800 1172,600 800,300 ###Markdown Add a header string with `header`* Add header text to the file with the `header` keyword.* Include column titles in the `header` keyword. ###Code header="""Distance (D), Header(H) header lines are automatically commented out""" newdata = numpy.vstack([D,H]).T numpy.savetxt("data/mydata3.txt", newdata, delimiter=',', header=header, fmt='%.6g') !cat data/mydata3.txt ###Output # Distance (D), Header(H) # header lines are automatically commented out 1500,1000 1340,828 1328,800 1172,600 800,300 ###Markdown More complex loadtxt commands can make your data more flexible* Using the `dtype` keyword allows fine control over the types of data you read.* Using `dtype` allows you to 'name' your data columns and reference them with the name. ###Code data = numpy.loadtxt('data/galileo_flat.csv', comments="#", skiprows=2, delimiter=',',\ dtype={'names':("Distance","Height"), 'formats':('f4','f4')}) print("data shape is ", data.shape) print("Distance data is ", data["Distance"]) ###Output data shape is (5,) Distance data is [1500. 1340. 1328. 1172. 800.]
TFversion_TrainingAutonomousCar.ipynb
###Markdown Dataset ###Code CSV = "TrainData.csv" ImageDir = "_TrainData" np.random.seed(0) ###Output _____no_output_____ ###Markdown Handling dataframe ###Code df = pd.read_csv(CSV) df.head(2) ###Output _____no_output_____ ###Markdown Dataset Visualization ###Code visualY = df['Steering'] visualY = visualY * 10 visualY = np.asarray(visualY, dtype= np.int32) unique, count = np.unique(visualY, return_counts =True) print(np.asarray((unique, count))) plt.bar(unique,count) plt.show() tempSet = df.loc[df['Steering'] <= -.2] frames = [df, tempSet, tempSet,tempSet ,tempSet] df = pd.concat(frames) type(df) visualY = df['Steering'] visualY = visualY * 10 visualY = np.asarray(visualY, dtype= np.int32) unique, count = np.unique(visualY, return_counts =True) print(np.asarray((unique, count))) plt.bar(unique,count) plt.show() tempSet = df.loc[df['Steering'] < -.5] tempSetPos = df.loc[df['Steering'] > 0] frames = [df, tempSet,tempSetPos, tempSet,tempSetPos,tempSetPos,tempSetPos,tempSet] df = pd.concat(frames) visualY = df['Steering'] visualY = visualY * 10 visualY = np.asarray(visualY, dtype= np.int32) unique, count = np.unique(visualY, return_counts =True) print(np.asarray((unique, count))) X = df[['Left','Center','Right']] Y = df['Steering'] plt.bar(unique,count) plt.show() X = X.values Y = Y.values X.shape, Y.shape ###Output _____no_output_____ ###Markdown Train test set ###Code X_train, X_test, y_train, y_test = train_test_split(X,Y, test_size =0.2, random_state = None, shuffle = True) X_train.shape, y_train.shape X_test.shape, y_test.shape ###Output _____no_output_____ ###Markdown Image details ###Code height = 32 width = 32 channel = 3 ###Output _____no_output_____ ###Markdown Common functions ###Code def readImage(imageName): global ImageDir return mpimg.imread(os.path.join(ImageDir, imageName.strip())) def getTrainBatch(batchSize,X,Y, isTraining): global height, width, channel indexRange = np.random.permutation(X.shape[0]) currentIndex =0 images = np.empty(shape =[batchSize, height,width,channel], dtype=np.float32) steer = np.empty(shape = [batchSize,1],dtype=np.float32) for index in indexRange: if isTraining: choiceIndex = np.random.choice(3) _image = imageResize(readImage(X[index][choiceIndex])) if choiceIndex ==0: steer[currentIndex] = (Y[index] + 0.2) elif choiceIndex ==1: steer[currentIndex] = Y[index] else: steer[currentIndex] = (Y[index] - 0.2) else: _image= imageResize(readImage(X[index][1])) steer[currentIndex] = Y[index] images[currentIndex] = (_image/127.5) -1 currentIndex = currentIndex+1 if currentIndex == batchSize: break return images,steer def imageResize(image): global height, width return cv2.resize(image, (width, height), cv2.INTER_AREA) ###Output _____no_output_____ ###Markdown Graph Parameters ###Code conv1_filters = 32 conv1_kSize = 5 conv1_strides = 1 conv1_padding = 'SAME' conv2_filters = 32 conv2_kSize = 5 conv2_strides = 2 conv2_padding = 'SAME' conv3_filters = 64 conv3_kSize = 5 conv3_strides = 2 conv3_padding = 'SAME' conv4_filters = 64 conv4_kSize = 3 conv4_strides = 2 conv4_padding = 'SAME' conv5_filters = 64 conv5_kSize = 3 conv5_strides = 1 conv5_padding = 'SAME' dense1_filter = 1000 dense2_filter = 128 output_unit = 1 tf.reset_default_graph() ###Output _____no_output_____ ###Markdown Placeholders ###Code X = tf.placeholder(tf.float32, shape=[None, height, width, channel], name = 'X_Placeholder') Y = tf.placeholder(tf.float32, shape=[None,1], name = 'Y_Placeholder') X, Y ###Output _____no_output_____ ###Markdown Graph ###Code conv1 = tf.layers.conv2d(inputs = X, filters = conv1_filters, kernel_size = conv1_kSize, strides = conv1_strides, padding = conv1_padding) conv1 conv2 = tf.layers.conv2d(inputs = conv1, filters = conv2_filters, kernel_size = conv2_kSize, strides = conv2_strides, padding = conv2_padding) conv2 conv3 = tf.layers.conv2d(inputs = conv2, filters = conv3_filters, kernel_size = conv3_kSize, strides = conv3_strides, padding = conv3_padding) conv3 conv4 = tf.layers.conv2d(inputs = conv3, filters = conv4_filters, kernel_size = conv4_kSize, strides = conv4_strides, padding = conv4_padding, name="conv4") conv4 conv5 = tf.layers.conv2d(inputs = conv4, filters = conv5_filters, kernel_size = conv5_kSize, strides = conv5_strides, padding = conv5_padding, name="conv5") conv5 flatten = tf.reshape(conv5, shape =[-1, conv5.shape[1].value * conv5.shape[2].value * conv5.shape[3].value]) flatten dense1 = tf.layers.dense(inputs = flatten, units = dense1_filter, activation = tf.nn.elu) dense1 dense2 =tf.layers.dense(inputs = dense1, units = dense2_filter, activation = tf.nn.elu) dense2 output = tf.layers.dense(inputs = dense2, units = output_unit) output Y.shape, output.shape loss = tf.losses.mean_squared_error(labels = Y, predictions = output) optimizer = tf.train.AdamOptimizer() train = optimizer.minimize(loss) saver = tf.train.Saver() init = tf.global_variables_initializer() ###Output _____no_output_____ ###Markdown Hyperparameters ###Code totalEpochs = 10 batchSize = 32 totalSets = (int)(len(X_train)/ batchSize) totalSets #graphs TrainingLossArray = np.empty(shape=[totalEpochs],dtype = np.float32) TestLossArray = np.empty(shape=[totalEpochs],dtype = np.float32) ###Output _____no_output_____ ###Markdown Training ###Code a = (int)(time.time() * 10000) + np.random.randint(100,size=1) with tf.Session() as sess: sess.run(init) for epoch in range(totalEpochs): currentIndex = 0 print("Epoch {0} started.......................".format(epoch)) for index in range(totalSets): x, y = getTrainBatch(batchSize, X_train, y_train, True) sess.run(train,feed_dict = {X:x, Y:y}) _loss = sess.run(loss,feed_dict = {X:x, Y:y}) if index % 100 == 0: print(" Completed count {0} and Loss : {1}".format(index,_loss)) print(" --------------------------------------------------------------------------------") print(" Trainign loss {0} ".format(_loss)) TrainingLossArray[epoch] = _loss x, y = getTrainBatch(batchSize, X_test, y_test, False) _loss = sess.run(loss,feed_dict = {X:x, Y:y}) print(" Test loss {0} ".format(_loss)) TestLossArray[epoch] = _loss modelName = "model/Model_" + str(a[0]) +"_____" + str(epoch) saver.save(sess,modelName) print("Model saved : ", modelName) x, y = getTrainBatch(1000, X_test, y_test, False) _yPred = sess.run(output,feed_dict = {X:x, Y:y}) _loss = sess.run(loss,feed_dict = {X:x, Y:y}) print(" Test loss {0}".format(_loss)) saver.save(sess,modelName) print("Completed") ###Output Epoch 0 started....................... Completed count 0 and Loss : 5.957803726196289 Completed count 100 and Loss : 0.03394746035337448 Completed count 200 and Loss : 0.03969404101371765 Completed count 300 and Loss : 0.03363872691988945 Completed count 400 and Loss : 0.018486790359020233 Completed count 500 and Loss : 0.037606559693813324 Completed count 600 and Loss : 0.029704757034778595 Completed count 700 and Loss : 0.014800004661083221 Completed count 800 and Loss : 0.025718403980135918 Completed count 900 and Loss : 0.011952178552746773 -------------------------------------------------------------------------------- Trainign loss 0.022728394716978073 Test loss 0.02102157473564148 Model saved : model/Model_15425395460637_____0 Epoch 1 started....................... Completed count 0 and Loss : 0.018008362501859665 Completed count 100 and Loss : 0.025861207395792007 Completed count 200 and Loss : 0.012491237372159958 Completed count 300 and Loss : 0.01675018109381199 Completed count 400 and Loss : 0.014935837127268314 Completed count 500 and Loss : 0.016359511762857437 Completed count 600 and Loss : 0.02713022381067276 Completed count 700 and Loss : 0.012450508773326874 Completed count 800 and Loss : 0.013137966394424438 Completed count 900 and Loss : 0.022013578563928604 -------------------------------------------------------------------------------- Trainign loss 0.02010934054851532 Test loss 0.008556215092539787 Model saved : model/Model_15425395460637_____1 Epoch 2 started....................... Completed count 0 and Loss : 0.024761663749814034 Completed count 100 and Loss : 0.017742976546287537 Completed count 200 and Loss : 0.014024957083165646 Completed count 300 and Loss : 0.013843515887856483 Completed count 400 and Loss : 0.01666743867099285 Completed count 500 and Loss : 0.015240740031003952 Completed count 600 and Loss : 0.018563304096460342 Completed count 700 and Loss : 0.014833538793027401 Completed count 800 and Loss : 0.020379208028316498 Completed count 900 and Loss : 0.016841385513544083 -------------------------------------------------------------------------------- Trainign loss 0.01233590766787529 Test loss 0.012782157398760319 Model saved : model/Model_15425395460637_____2 Epoch 3 started....................... Completed count 0 and Loss : 0.01000949926674366 Completed count 100 and Loss : 0.01622285135090351 Completed count 200 and Loss : 0.00921539030969143 Completed count 300 and Loss : 0.01390217524021864 Completed count 400 and Loss : 0.012011686339974403 Completed count 500 and Loss : 0.01210271567106247 Completed count 600 and Loss : 0.012698809616267681 Completed count 700 and Loss : 0.016898345202207565 Completed count 800 and Loss : 0.010021215304732323 Completed count 900 and Loss : 0.024219246581196785 -------------------------------------------------------------------------------- Trainign loss 0.011744080111384392 Test loss 0.014946043491363525 Model saved : model/Model_15425395460637_____3 Epoch 4 started....................... Completed count 0 and Loss : 0.012202995829284191 Completed count 100 and Loss : 0.006572953425347805 Completed count 200 and Loss : 0.01677410677075386 Completed count 300 and Loss : 0.010465624742209911 Completed count 400 and Loss : 0.010911883786320686 Completed count 500 and Loss : 0.019148729741573334 Completed count 600 and Loss : 0.008076565340161324 Completed count 700 and Loss : 0.010886328294873238 Completed count 800 and Loss : 0.01144014485180378 Completed count 900 and Loss : 0.012792317196726799 -------------------------------------------------------------------------------- Trainign loss 0.009549302980303764 Test loss 0.00735051091760397 Model saved : model/Model_15425395460637_____4 Epoch 5 started....................... Completed count 0 and Loss : 0.014001871459186077 Completed count 100 and Loss : 0.007088589947670698 Completed count 200 and Loss : 0.00874466821551323 Completed count 300 and Loss : 0.013246467337012291 Completed count 400 and Loss : 0.017277300357818604 Completed count 500 and Loss : 0.014141371473670006 Completed count 600 and Loss : 0.01178213395178318 Completed count 700 and Loss : 0.007392230909317732 Completed count 800 and Loss : 0.015902362763881683 Completed count 900 and Loss : 0.01170360017567873 -------------------------------------------------------------------------------- Trainign loss 0.010131200775504112 Test loss 0.007869934663176537 Model saved : model/Model_15425395460637_____5 Epoch 6 started....................... Completed count 0 and Loss : 0.013822907581925392 Completed count 100 and Loss : 0.009814513847231865 Completed count 200 and Loss : 0.011550010181963444 Completed count 300 and Loss : 0.015861298888921738 Completed count 400 and Loss : 0.0067636012099683285 Completed count 500 and Loss : 0.010816155932843685 Completed count 600 and Loss : 0.015764955431222916 Completed count 700 and Loss : 0.024696968495845795 Completed count 800 and Loss : 0.009034502319991589 Completed count 900 and Loss : 0.010379107668995857 -------------------------------------------------------------------------------- Trainign loss 0.011758310720324516 Test loss 0.007323317229747772 Model saved : model/Model_15425395460637_____6 Epoch 7 started....................... Completed count 0 and Loss : 0.009674912318587303 Completed count 100 and Loss : 0.00991353951394558 Completed count 200 and Loss : 0.021988237276673317 Completed count 300 and Loss : 0.008852913975715637 Completed count 400 and Loss : 0.011050541885197163 Completed count 500 and Loss : 0.0131304282695055 Completed count 600 and Loss : 0.009884987026453018 Completed count 700 and Loss : 0.0070093898102641106 Completed count 800 and Loss : 0.010978732258081436 Completed count 900 and Loss : 0.008886807598173618 -------------------------------------------------------------------------------- Trainign loss 0.01353539526462555 Test loss 0.0217283945530653 Model saved : model/Model_15425395460637_____7 Epoch 8 started....................... Completed count 0 and Loss : 0.008982986211776733 Completed count 100 and Loss : 0.010816440917551517 Completed count 200 and Loss : 0.00935292337089777 Completed count 300 and Loss : 0.009537456557154655 Completed count 400 and Loss : 0.0074629876762628555 Completed count 500 and Loss : 0.01001269742846489 Completed count 600 and Loss : 0.012569618411362171 Completed count 700 and Loss : 0.00762396352365613 Completed count 800 and Loss : 0.012749603018164635 Completed count 900 and Loss : 0.0074554854072630405 -------------------------------------------------------------------------------- Trainign loss 0.010573378764092922 Test loss 0.015552621334791183 Model saved : model/Model_15425395460637_____8 Epoch 9 started....................... Completed count 0 and Loss : 0.006878113839775324 Completed count 100 and Loss : 0.007174311671406031 Completed count 200 and Loss : 0.014582308009266853 Completed count 300 and Loss : 0.009218496270477772 Completed count 400 and Loss : 0.007633640430867672 Completed count 500 and Loss : 0.007256672717630863 Completed count 600 and Loss : 0.01507255993783474 Completed count 700 and Loss : 0.008994203060865402 Completed count 800 and Loss : 0.009660067036747932 Completed count 900 and Loss : 0.007024089805781841 -------------------------------------------------------------------------------- Trainign loss 0.006193377077579498 Test loss 0.010820752941071987 Model saved : model/Model_15425395460637_____9 Test loss 0.010033893398940563 ###Markdown Training loss ###Code _trainLoss = np.around(TrainingLossArray, decimals=4) _testLoss = np.around(TestLossArray, decimals=4) line1, = plt.plot(_trainLoss, label='Train loss') line2, = plt.plot(_testLoss, label='Test loss') first_legend = plt.legend(handles=[line1], loc =1) ax = plt.gca().add_artist(first_legend) plt.legend(handles=[line2], loc =4) plt.show() startPoint = 70 line1, = plt.plot(y[startPoint:startPoint+35], label='True value') line2, = plt.plot(_yPred[startPoint:startPoint+35],label='Pred value') first_legend = plt.legend(handles=[line1], loc =1) ax = plt.gca().add_artist(first_legend) plt.legend(handles=[line2], loc =4) plt.savefig("graph1.jpg") plt.imshow(imageResize(readImage(X_train[900][0]))) a.shape b.shape ###Output _____no_output_____
ID by county.ipynb
###Markdown Idaho updates daily at 2pm CDT ###Code from selenium import webdriver import time import pandas as pd import pendulum import re import yaml from selenium.webdriver.chrome.options import Options chrome_options = Options() #chrome_options.add_argument("--disable-extensions") #chrome_options.add_argument("--disable-gpu") #chrome_options.add_argument("--no-sandbox) # linux only chrome_options.add_argument("--start-maximized") # chrome_options.add_argument("--headless") chrome_options.add_argument("user-agent=[Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:73.0) Gecko/20100101 Firefox/73.0]") with open('config.yaml', 'r') as f: config = yaml.safe_load(f.read()) state = 'ID' scrape_timestamp = pendulum.now().strftime('%Y%m%d%H%M%S') url = 'https://coronavirus.idaho.gov/' def fetch(): driver = webdriver.Chrome('../20190611 - Parts recommendation/chromedriver', options=chrome_options) driver.get(url) time.sleep(5) datatbl = driver.find_element_by_id('tablepress-1') data = [] for row in datatbl.find_elements_by_css_selector('tr'): data.append([cell.text for cell in row.find_elements_by_css_selector('td')]) d = [] for row in data: if len(row) ==4: d.append(row[1:]) else: d.append(row) page_source = driver.page_source driver.close() return pd.DataFrame(d, columns=['county','positive_cases','deaths']), page_source def save(df, source): df.to_csv(f"{config['data_folder']}/{state}_county_{scrape_timestamp}.txt", sep='|', index=False) with open(f"{config['data_source_backup_folder']}/{state}_county_{scrape_timestamp}.html", 'w') as f: f.write(source) def run(): df, source = fetch() save(df, source) ###Output _____no_output_____
notebooks/audioDSP-intro_phase_vocoder.ipynb
###Markdown PROCESAMIENTO DIGITAL DE SEÑALES DE AUDIO Introducción al algoritmo de Phase Vocoder ###Code %matplotlib inline import math import time import numpy as np import matplotlib.pyplot as plt from scipy import signal from scipy.io import wavfile import IPython.display as ipd ###Output _____no_output_____ ###Markdown **NOTA:** *Las siguientes dos celdas solo son necesarias para descargar el archivo de ejemplo. Ignórelas si va a trabajar con sus propios archivos de audio.* ###Code !pip install wget import wget ###Output _____no_output_____ ###Markdown Cómo correr el notebookSe puede bajar y correr el notebook de forma local en una computadora.O también se puede correr en Google Colab usando el siguiente enlace. Run in Google Colab IntroducciónEste ejercicio sirve de introducción al algoritmo de phase vocoder. Se analiza una señal de audio usando la STFT y luego se la reconstruye antitransformando la DFT de cada trama y combinándolas mediante el método de Overlap-Add.A continuación se carga la señal de audio que será procesada. ###Code # download audio file wget.download('https://github.com/mrocamora/audio-dsp/blob/main/audio/singing_voice.wav?raw=true') # read the audio file to process (from https://openairlib.net/) filename = 'singing_voice.wav' # filename = './audio/trumpet.wav' # read audio file fs, x = wavfile.read(filename) # normalize maximum (absolute) amplitude x = x / np.max(abs(x)) * 0.9 # time corresponding to the audio signal time_x = np.arange(0, x.size)/fs # plot the audio signal waveform plt.figure(figsize=(12,6)) ax1 = plt.subplot(2, 1, 1) plt.plot(time_x, x) plt.xlabel('Time (s)') plt.ylabel('Amplitude') ipd.Audio(x, rate=fs) ###Output _____no_output_____ ###Markdown Parte 1En esta primera parte se analiza el efecto del enventanado y las restricciones que debe cumplir según el método de **overlap-add**. Complete el código que se proporciona a continuación y siga los siguientes pasos. 1. Acumular adecuadamente las ventanas de análisis de acuerdo al algoritmo de **overlap-add**.2. Calcular el factor de escalado de amplitud $C$, para el caso en que el solapamiento de las ventanas es constante.3. Cambiar el factor de decimación temporal ($R$) y analice los resultados. En particular pruebe para $\frac{1}{4} L$ y $\frac{3}{4} L$.4. Analice el resultado para otras ventanas suavizantes (e.g. Hamming, Blackman) usando los mismos factores de decimación. ###Code # length of the input signal M = x.size; # length of the analysis window in samples L = 2048 # hop size in samples. R = int(L/2) # total number of analysis frames num_frames = int(np.floor((M-L)/R)) # analysis window window = signal.windows.get_window('hann', L) # overlap-add (OLA) of the analysis windows olawin = np.zeros((num_frames-1)*R+L) # for each analysis frame for ind in range(num_frames): # initial index of current window n_ini = ind * R # overlap-add the window # olawin[??] = # compute the amplitude scaling factor # C = print("C = ", C) print("max(olawin) = ", max(olawin)) # plot the analysis window plt.figure(figsize=(12,6)) ax1 = plt.subplot(2, 1, 1) plt.plot(window, 'r') plt.ylabel('Amplitude') plt.xlabel('Time (samples)') plt.title('Analysis window') # plot the overlap-add of the analysis windows plt.figure(figsize=(12,6)) ax1 = plt.subplot(2, 1, 1) plt.plot(olawin) plt.xlabel('Time (samples)') plt.ylabel('Amplitude') plt.title('Overlap-add of the analysis windows') ###Output _____no_output_____ ###Markdown Parte 2El siguiente código implementa la etapa de análisis del algoritmo de **phase-vocoder**, es decir una STFT. Complete el código que se proporciona a continuación y siguiendo los siguientes pasos. 1. Calcular la DFT de cada trama de señal aplicando una ventana suavizante.2. Calcular el valor de frequencia de cada bin en radianes.3. Calcular el instante temporal en muestras de cada trama. ###Code def analysis_STFT(x, L=2048, R=256, win='hann'): """ compute the analysis phase of the phase vocoder, i.e. the STFT of the input audio signal Parameters ---------- x : numpy array input audio signal (mono) as a numpy 1D array. L : int window length in samples. R : int hop size in samples. win : string window type as defined in scipy.signal.windows. Returns ------- X_stft : numpy array STFT of x as a numpy 2D array. omega_stft : numpy array frequency values in radians. samps_stft : numpy array time sample at the begining of each frame. """ # length of the input signal M = x.size; # number of points to compute the DFT (FFT) N = L # analysis window window = signal.windows.get_window(win, L) # total number of analysis frames num_frames = int(np.floor((M - L) / R)) # initialize stft X_stft = np.zeros((N, num_frames), dtype = complex) # process each frame for ind in range(num_frames): # initial and ending points of the frame n_ini = int(ind * R) n_end = n_ini + L # signal frame # xr = # save DFT of the signal frame # X_stft[:, ind] = # frequency values in radians # omega_stft = # time sample at the center of each frame # samps_stft = return X_stft, omega_stft, samps_stft ###Output _____no_output_____ ###Markdown Parte 3Una vez completada la implementación de la función `analysis_STFT` siga los siguientes pasos.1. Ejecute la función `analysis_STFT` para distintos valores de $L$ y $R$ y analice el resultado en el espectragrama.2. ¿Qué controla el parámetro $L$? ¿Qué controla el parámetro $R$? 3. ¿Qué relación deben cumplir $L$ y $R$? ¿Por qué? ###Code # window length in samples L = 2048 # hop size in samples R = 256 # compute STFT X_stft, omega_stft, samps_stft = analysis_STFT(x, L, R, win='hann') # max frequency index ind_fmax = int(X_stft.shape[0]/2)+1 # frequency values (Hz) stft_freqs = omega_stft[:ind_fmax]*fs/(2*np.pi) # time values of the stft stft_time = samps_stft/fs plt.figure(figsize=(12,8)) ax1 = plt.subplot(2, 1, 1) plt.pcolormesh(stft_time, stft_freqs, 20*np.log10(np.abs(X_stft[:ind_fmax, :])), cmap='jet') plt.ylabel('Frequency [Hz]') plt.xlabel('Time [sec]') ###Output _____no_output_____ ###Markdown Parte 4El siguiente código implementa la etapa de síntesis a partir de la STFT. Complete el código que se proporciona a continuación y siguiendo los siguientes pasos. 1. Calcule la reconstrucción de cada trama de señal.2. Acumule tramas sucesivas según el método de **overlap-adds**.3. Modifique la amplitud de la señal obtenida por el factor de compensación del enventanado. ###Code def synthesis_STFT(X_stft, L=2048, R=256, win='hann'): """ compute the synthesis using the IFFT of each frame combined with overlap-add Parameters ---------- X_stft : numpy array STFT of x as a numpy 2D array. L : int window length in samples. R : int hop size in samples. win : string window type as defined in scipy.signal.windows. Returns ------- x : numpy array output audio signal (mono) as a numpy 1D array. """ # number of frequency bins N = X_stft.shape[0]; # analysis window window = signal.windows.get_window(win, L) # total number of analysis frames num_frames = X_stft.shape[1] # initialize otuput signal in the time domain y = np.zeros(num_frames * R + L) # process each frame for ind in range(num_frames): # reconstructed signal frame # yr = # initial and ending points of the frame # n_ini = # n_end = # overlap-add the signal frame # y[n_ini:n_end] = # compute the amplitude scaling factor # C = # compensate the amplitude scaling factor y /= C return y ###Output _____no_output_____ ###Markdown Parte 5Una vez completada la implementación de la función `synthesis_STFT` siga los siguientes pasos.1. Ejecute la función `analysis_STFT` y luego la función `synthesis_STFT` usando $L=2048$ y $R=256$. 2. Evalúe la reconstrucción en términos de la forma de onda. Evalúe la reconstrucción auditivamente.3. Ejecute la función `analysis_STFT` usando $L=2048$ y $R=256$. Ejecute la función `synthesis_STFT` usando $L=2048$ y $R=512$. 4. Antes de escuchar el resultado indique qué tipo de modificación temporal espera que se produzca. ¿Una acortamiento o alargamiento temporal?5. Evalúe la reconstrucción en términos de la forma de onda. Evalúe la reconstrucción auditivamente.6. Repita la parte 3 en adelante usando $L=2048$ y $R=128$. ###Code # window length in samples L = 2048 # hop size in samples R = 256 # compute STFT X_stft, omega_stft, samps_stft = analysis_STFT(x, L, R, win='hann') # hop size in samples R = 256 # compute the synthesis from the STFT y = synthesis_STFT(X_stft, L, R, win='hann') # time corresponding to the audio signal time_y = np.arange(0, y.size)/fs # plot the audio signal waveform plt.figure(figsize=(12,6)) ax1 = plt.subplot(2, 1, 1) plt.plot(time_x, x) plt.ylabel('Amplitude') ax1 = plt.subplot(2, 1, 2) plt.plot(time_y, y) plt.xlabel('Time (s)') plt.ylabel('Amplitude') ipd.Audio(x, rate=fs) ipd.Audio(y, rate=fs) ###Output _____no_output_____
Topic Modeling/Topic Modeling.ipynb
###Markdown Tokenizer for Tweets ###Code tknzr = TweetTokenizer(preserve_case=False, # Convertir a minúsculas reduce_len=True, # Reducir caracteres repetidos strip_handles=False) # Mostrar @usuarios ###Output _____no_output_____ ###Markdown Create Stemmer of class Snowball ###Code stmmr = snowballstemmer.stemmer('Spanish') ###Output _____no_output_____ ###Markdown Stopword ###Code spec_chars = ["…",'"',"“","/","(",")","[","]","?","¿","!","¡", "rt",":","…",",","\n","#","\t","",".","$", "...","-","🤢"] # create English stop words list en_stop = get_stop_words('es') def clean_tweet(tmp_tweet): """ Eliminar tokens que: - Estén dentro de lista_de_paro. - Sean ligas. - Si es una mención i.e @potus, se cambia por token genérico @usuario. """ return [_ for _ in tmp_tweet if _ not in spec_chars and not _.startswith(('http', 'htt'))] nuevos_tweets = [] for i in tweets.find(): if "retweeted_status" in i: # Si es retweet... tokens = tknzr.tokenize(i["retweeted_status"]['text']) stopped_tokens = [i for i in tokens if not i in en_stop] stemmed_tokens = clean_tweet(stopped_tokens) nuevos_tweets.append(stemmed_tokens) else: # Si no es retweet... tokens = tknzr.tokenize(i['text']) stopped_tokens = [i for i in tokens if not i in en_stop] stemmed_tokens = clean_tweet(stopped_tokens) nuevos_tweets.append(stemmed_tokens) df = pd.DataFrame() df["tweet"] = nuevos_tweets df.head(100) ###Output _____no_output_____ ###Markdown turn our tokenized documents into a id term dictionary ###Code dictionary = corpora.Dictionary(df["tweet"]) ###Output _____no_output_____ ###Markdown convert tokenized documents into a document-term matrix ###Code corpus = [dictionary.doc2bow(text) for text in df["tweet"]] ###Output _____no_output_____ ###Markdown generate LDA model ###Code ldamodel = LdaModel(corpus, num_topics = 20, id2word = dictionary, passes = 20, minimum_probability = 0.05) print(ldamodel) print(ldamodel.print_topics()) ldamodel.save(fname="ldamodel") ###Output _____no_output_____
delhi.ipynb
###Markdown Number of routes ###Code routes.route_long_name.unique().shape # Number of routes per km2 1270 / 1484 # Number of routes per capita 1270 / 16_787_941 ###Output _____no_output_____ ###Markdown Number of stops ###Code stops = pd.read_csv('data/india/GTFS/stops.txt') stops.stop_id.unique().shape # Number of stops per km2 4192 / 1484 # Number of stops per capita 4192 / 16_787_941 ###Output _____no_output_____ ###Markdown Average number of stops per route Should we make a distinction between route and trip? What if a route has two different trips that goes to a different set of stations? Why should we treat them a single route, rather than two separate routes?If we ignore routes and only count trips, the calculation becomes much easier ###Code trips = pd.read_csv('data/india/GTFS/trips.txt') stop_times = pd.read_csv('data/india/GTFS/stop_times.txt') trip_to_stop_id = stop_times[['trip_id', 'stop_id']].drop_duplicates() trip_to_stop_id num_stops_in_every_trip = trip_to_stop_id.groupby('trip_id').stop_id.count() num_stops_in_every_trip sns.histplot(x=num_stops_in_every_trip, bins=30) plt.xlabel('Number of stops') plt.title('Delhi') sns.despine() plt.savefig('figures/d_nstops.png') num_stops_in_every_trip.to_csv('gen/d_nstops.csv') num_stops_in_every_trip.mean() num_stops_in_every_trip.median() ###Output _____no_output_____ ###Markdown Restore old trip to routes code ###Code route_to_trip_id = trips[['route_id', 'trip_id']].drop_duplicates() route_to_trip_id def f(x): ''' input: dataframe with columns trip_id and stop_id. the trip_id has only one unique value output: list of all stop ids that this trip stops at ''' return x.stop_id.to_list() trip_stops = trip_to_stop_id.groupby('trip_id').apply(f) trip_stops def g(x): '''Same as `f` above but collects trip ids instead of stop ids''' return x.trip_id.to_list() route_trips = route_to_trip_id.groupby('route_id').apply(g) route_trips def h(x): # mean len of every trip in this route return np.mean([len(trip_stops[trip_id]) for trip_id in x]) num_stops_for_every_route = route_trips.apply(h) num_stops_for_every_route # Average number of stops num_stops_for_every_route.mean() num_stops_for_every_route.plot.hist() num_stops_for_every_route.to_csv('gen/d_nstops2.csv') ###Output _____no_output_____ ###Markdown Average route length Again, we're going to consider each trip as a route by themselves ###Code # wgs84 is in degrees, pseudo mercator is in meters wgs84 = pyproj.CRS('EPSG:4326') pseudo_mercator = pyproj.CRS('EPSG:3857') project = pyproj.Transformer.from_crs(wgs84, pseudo_mercator, always_xy=True).transform def transformer(p: Point): return transform(project, p) ###Output _____no_output_____ ###Markdown Need to use the stop_sequence to ensure the stops are in order ###Code stop_times_with_loc = stop_times.merge(stops, on='stop_id') stop_times_with_loc ###Output _____no_output_____ ###Markdown I can't find the code for this onebut 175STLDOWN and 133DOWN shares the first half - then continues after the last stophttps://www.transsee.ca/stoplist?a=delhi&r=1102https://www.transsee.ca/stoplist?a=delhi&r=1230 ###Code stop_times_with_loc[stop_times_with_loc.trip_id == '0_20_20'].sort_values('stop_sequence') trips[trips.trip_id == '0_20_20'] routes[routes.route_id == 0] def f(x): df = x.sort_values('stop_sequence') points = df[['stop_lon', 'stop_lat']].apply( lambda row: transformer(Point(row.stop_lon, row.stop_lat)), axis=1 ) return LineString(points.reset_index(drop=True)) trip_lines = stop_times_with_loc.groupby('trip_id').apply(f) trip_lines trip_lengths = trip_lines.apply(lambda x: x.length) trip_lengths # Average trip length in meters trip_lengths.mean() trip_lengths.median() sns.histplot(x=trip_lengths, bins=40) sns.despine() plt.title('Delhi') plt.xlabel('Route length (m)') plt.savefig('figures/d_rlengths.png') trip_lengths.to_csv('gen/d_rlengths.csv') trip_lengths.sort_values(ascending=False).head() ###Output _____no_output_____ ###Markdown Restore old code again ###Code # Very slow def h(x): """x is a list of trip_ids, all belong to the same route""" lens = [] for trip_id in x: points = [] # for every stop in this trip, get its point coordinates for stop in trip_stops[trip_id]: df = stops[stops.stop_id == stop] x_c = df.stop_lon.iloc[0] y_c = df.stop_lat.iloc[0] points.append(transformer(Point(x_c, y_c))) # line length of this trip lens.append(LineString(points).length) # mean linestring len of every trip in this route return np.mean(lens) route_lengths = route_trips.apply(h) route_lengths # Average route length in meters route_lengths.mean() route_lengths.plot.hist() route_lengths.to_csv('gen/d_rlengths2.csv') ###Output _____no_output_____ ###Markdown Average distance between stops ###Code def calc_distances(x): ''' input: [(float, float)] a list of coordinates output: [float] the distances between each coordinates ''' return [Point(a).distance(Point(b)) for a, b in zip(x, x[1:])] def f(x): df = x.sort_values('stop_sequence') points = df[['stop_lon', 'stop_lat']].apply( lambda row: transformer(Point(row.stop_lon, row.stop_lat)), axis=1 ) return calc_distances(points.reset_index(drop=True)) trip_stop_dists = stop_times_with_loc.groupby('trip_id').apply(f) trip_stop_dists trip_avg_stop_dists = trip_stop_dists.apply(np.mean) trip_avg_stop_dists # Global average distance between stops (meters) trip_avg_stop_dists.mean() trip_avg_stop_dists.median() sns.histplot(x=trip_avg_stop_dists) # The individual distances between every stops in every route trip_stop_dists.explode().astype(float).describe() trip_stop_dists.explode().astype(float).plot.box() trip_avg_stop_dists.sort_values(ascending=False) ###Output _____no_output_____ ###Markdown Median bus speed Removed because some stops don't have an associated stop time: ###Code np.setdiff1d(stops.stop_id.unique(), stop_times.stop_id.unique()) stop_times[stop_times.stop_id == 1730] stops[stops.stop_id == 1730] ###Output _____no_output_____ ###Markdown Number of links Number of nodes Network diameter ###Code def f(x): df = x.sort_values('stop_sequence') # networkx refuses to take Points so we need to transform it back to floats def g(row): p = transformer(Point(row.stop_lon, row.stop_lat)) return (p.x, p.y) points = df[['stop_lon', 'stop_lat']].apply(g,axis=1) # combine all stops into a single list for the single trip_id return points.reset_index(drop=True).to_list() trip_stop_coords = stop_times_with_loc.groupby('trip_id').apply(f) trip_stop_coords trip_stop_coords_dict = trip_stop_coords.to_dict() g = nx.from_dict_of_lists(trip_stop_coords_dict) #nx.algorithms.distance_measures.diameter(g) ###Output _____no_output_____ ###Markdown Network density ###Code #nx.classes.function.density(g) ###Output _____no_output_____
Homework/To Do/Homework 03.ipynb
###Markdown Design Choices in Convolutional Neural Networks Importing packages ###Code import numpy as np import keras from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D from keras import backend as K from keras.preprocessing import image from keras.applications.mobilenet import MobileNet from keras.applications.vgg16 import preprocess_input, decode_predictions from keras.models import Model import timeit import warnings warnings.filterwarnings('ignore') ###Output Using TensorFlow backend. ###Markdown Preparing Dataset ###Code batch_size = 128 num_classes = 10 epochs = 2 # input image dimensions img_rows, img_cols = 28, 28 # the data, shuffled and split between train and test sets (x_train, y_train), (x_test, y_test) = mnist.load_data() if K.image_data_format() == 'channels_first': x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols) input_shape = (1, img_rows, img_cols) else: x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) ###Output Downloading data from https://s3.amazonaws.com/img-datasets/mnist.npz 11493376/11490434 [==============================] - 0s 0us/step x_train shape: (60000, 28, 28, 1) 60000 train samples 10000 test samples ###Markdown Part 1: Influence of convolution size Try the models with different convolution sizes 5x5, 7x7 and 9x9 etc. Analyze the number of model parameters, accuracy and training time Model with (3 x 3) Convolution ###Code K.clear_session() start = timeit.default_timer() model = Sequential() model.add(Conv2D(8, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(16, (3, 3), activation='relu')) model.add(Flatten()) model.add(Dense(32, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.summary() model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) end = timeit.default_timer() print("Time Taken to run the model:",end - start, "seconds") ###Output WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:107: The name tf.reset_default_graph is deprecated. Please use tf.compat.v1.reset_default_graph instead. Model: "sequential_1" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_1 (Conv2D) (None, 26, 26, 8) 80 _________________________________________________________________ conv2d_2 (Conv2D) (None, 24, 24, 16) 1168 _________________________________________________________________ flatten_1 (Flatten) (None, 9216) 0 _________________________________________________________________ dense_1 (Dense) (None, 32) 294944 _________________________________________________________________ dense_2 (Dense) (None, 10) 330 ================================================================= Total params: 296,522 Trainable params: 296,522 Non-trainable params: 0 _________________________________________________________________ Train on 60000 samples, validate on 10000 samples Epoch 1/2 60000/60000 [==============================] - 36s 595us/step - loss: 0.2562 - acc: 0.9224 - val_loss: 0.0807 - val_acc: 0.9737 Epoch 2/2 60000/60000 [==============================] - 38s 625us/step - loss: 0.0735 - acc: 0.9784 - val_loss: 0.0595 - val_acc: 0.9818 Time Taken to run the model: 73.62484016500002 seconds ###Markdown Try models with different Convolution sizes ###Code # Write your code here. Use the same architecture as above. # Write your code here. Use the same architecture as above. # Write your code here. Use the same architecture as above. ###Output _____no_output_____ ###Markdown Write your findings about activations here? 1. Finding 1 2. Finding 2 Part 2: Influence of Striding Try the models with different stride sizes such as 2,3,4 etc. Analyze the number of model parameters, accuracy and training time Model with Convolution with 2 Steps ###Code start = timeit.default_timer() model = Sequential() model.add(Conv2D(8, kernel_size=(3, 3), strides=2, activation='relu', input_shape=input_shape)) model.add(Conv2D(16, (3, 3), strides=2, activation='relu')) model.add(Flatten()) model.add(Dense(32, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.summary() model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) end = timeit.default_timer() print("Time Taken to run the model:",end - start, "seconds") # Write your code here. Use the same architecture as above. # Write your code here. Use the same architecture as above. # Write your code here. Use the same architecture as above. ###Output _____no_output_____ ###Markdown Write your findings about influence of striding here? 1. Finding 1 2. Finding 2 Part 3: Influence of Padding Try the models with padding and without padding. Analyze the number of model parameters, accuracy and training time Model with (3 x 3) Convolution with Same Padding ###Code start = timeit.default_timer() model = Sequential() model.add(Conv2D(8, kernel_size=(3, 3), strides=1, padding='same', activation='relu', input_shape=input_shape)) model.add(Conv2D(16, (3, 3), strides=1, padding='same', activation='relu')) model.add(Flatten()) model.add(Dense(32, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.summary() model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) end = timeit.default_timer() print("Time Taken to run the model:",end - start, "seconds") # Write your code here. Use the same architecture as above. # Write your code here. Use the same architecture as above. ###Output _____no_output_____ ###Markdown Write your findings about influence of padding here? 1. Finding 1 2. Finding 2 Part 4: Influence of Pooling Try the models with different pooling window sizes such as 2x2, 3x3, 4x4 etc. Analyze the number of model parameters, accuracy and training time Model with (3 x 3) Convolution with Pooling (2 x 2) ###Code start = timeit.default_timer() model = Sequential() model.add(Conv2D(8, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(16, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(32, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.summary() model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) end = timeit.default_timer() print("Time Taken to run the model:",end - start, "seconds") ###Output _____no_output_____ ###Markdown Model with (3 x 3) Convolution with Pooling (3 x 3) ###Code # Write your code here # Use the same model design from the above cell # Write your code here # Use the same model design from the above cell ###Output _____no_output_____
5-ExamProblems/.src/EX1-F2020-Deploy/Exam1-Deploy-Student-Version.ipynb
###Markdown ENGR 1330 Exam 1 Sec 003/004 Fall 2020Take Home Portion of Exam 1 Full name R: HEX: ENGR 1330 Exam 1 Sec 003/004 Date: Question 1 (1 pts):Run the cell below, and leave the results in your notebook (Windows users may get an error, leave the error in place) ###Code #### RUN! the Cell #### import sys ! hostname ! whoami print(sys.executable) # OK if generates an exception message on Windows machines ###Output theodores-MBP theodore /opt/anaconda3/bin/python ###Markdown Question 2 (9 pts):- __When it is 8:00 in Lubbock,__ - __It is 9:00 in New York__ - __It is 14:00 in London__ - __It is 15:00 in Cairo__ - __It is 16:00 in Istanbul__ - __It is 19:00 in Hyderabad__ - __It is 22:00 in Tokyo__ __Write a function that reports the time in New York, London, Cairo, Istanbul, Hyderabad, and Tokyo based on the time in Lubbock. Use a 24-hour time format. Include error trapping that:__1- Issues a message like "Please Enter A Number from 00 to 23" if the first input is numeric but outside the range of [0,23].2- Takes any numeric input for "Lubbock time" selection , and forces it into an integer.3- Issues an appropriate message if the user's selection is non-numeric.__Check your function for these times:__- 8:00- 17:00- 0:00 ###Code # Code and run your solution here: ###Output _____no_output_____ ###Markdown Question 3 (28 pts): Follow the steps below. Add comments to your script and signify when each step and each task is done. *hint: For this problem you will need the numpy and pandas libraries.- __STEP1: There are 8 digits in your R. Define a 2x4 array with these 8 digits, name it "Rarray", and print it__- __STEP2: Find the maximum value of the "Rarray" and its position__- __STEP3: Sort the "Rarray" along the rows, store it in a new array named "Rarraysort", and print the new array out__- __STEP4: Define and print a 4x4 array that has the "Rarray" as its two first rows, and "Rarraysort" as its next rows. Name this new array "DoubleRarray"__- __STEP5: Slice and print a 4x3 array from the "DoubleRarray" that contains the last three columns of it. Name this new array "SliceRarray".__- __STEP6: Define the "SliceRarray" as a panda dataframe:__ - name it "Rdataframe", - name the rows as "Row A","Row B","Row C", and "Row D" - name the columns as "Column 1", "Column 2", and "Column 3"- __STEP7: Print the first few rows of the "Rdataframe".__- __STEP8: Create a new dataframe object ("R2dataframe") by adding a column to the "Rdataframe", name it "Column X" and fill it with "None" values. Then, use the appropriate descriptor function and print the data model (data column count, names, data types) of the "R2dataframe"__- __STEP9: Replace the **'None'** in the "R2dataframe" with 0. Then, print the summary statistics of each numeric column in the data frame.__- __STEP10: Define a function based on the equation below, apply on the entire "R2dataframe", store the results in a new dataframe ("R3dataframe"), and print the results and the summary statistics again.__ $$ y = x^2 - 5x +7 $$- __STEP11: Print the number of occurrences of each unique value in "Column 3"__- __STEP12: Sort the data frame with respect to "Column 1" with a descending order and print it__- __STEP13: Write the final format of the "R3dataframe" on a CSV file, named "Rfile.csv"__- __STEP14: Read the "Rfile.csv" and print its content.__** __Make sure to attach the "Rfile.csv" file to your midterm exam submission.__ ###Code # Code and Run your solution here: ###Output _____no_output_____ ###Markdown Problem 4 (32 pts)Graphing Functions Special Functions Consider the two functions listed below:\begin{equation}f(x) = e^{-\alpha x}\label{eqn:fofx}\end{equation}\begin{equation}g(x) = \gamma sin(\beta x)\label{eqn:gofx}\end{equation}Prepare a plot of the two functions on the same graph. Use the values in Table below for $\alpha$, $\beta$, and $\gamma$.|Parameter|Value||:---|---:||$\alpha$|0.50||$\beta$|3.00||$\gamma$|$\frac{\pi}{2}$|The plot should have $x$ values ranging from $0$ to $10$ (inclusive) in sufficiently small increments to see curvature in the two functions as well as to identify the number and approximate locations of intersections. In this problem, intersections are locations in the $x-y$ plane where the two "curves" cross one another of the two plots. By-hand evaluate f(x) for x=1, alpha = 1/2 (Simply enter your answer from a calculator)f(x) = By-hand evaluate g(x) for x=3.14, beta = 1/2, gamma = 2 (Simply enter your answer from a calculator)g(x) = ###Code # Define the first function f(x,alpha), test the function using your by hand answer # Define the second function g(x,beta,gamma), test the function using your by hand answer # Built a list for x that ranges from 0 to 10, inclusive, with adjustable step sizes for plotting later on # Build a plotting function that plots both functions on the same chart # Using the plot as a guide, find the approximate values of x where the two curves intercept (i.e. f(x) = g(x)) # You can either use interactive input, or direct specify x values, but need to show results ###Output _____no_output_____ ###Markdown Bonus Problem 1. Extra Credit (You must complete the regular problems)!__create a class to compute the average grade (out of 10) of the students based on their grades in Quiz1, Quiz2, the Mid-term, Quiz3, and the Final exam.__| Student Name | Quiz 1 | Quiz 2 | Mid-term | Quiz 3 | Final Exam || ------------- | -----------| -----------| -------------| -----------| -------------|| Harry | 8 | 9 | 8 | 10 | 9 || Ron | 7 | 8 | 8 | 7 | 9 || Hermione | 10 | 10 | 9 | 10 | 10 || Draco | 8 | 7 | 9 | 8 | 9 || Luna | 9 | 8 | 7 | 6 | 5 |1. __Use docstrings to describe the purpose of the class.__2. __Create an object for each car brand and display the output as shown below.__"Student Name": **Average Grade** 3. __Create and print out a dictionary with the student names as keys and their average grades as data.__ ###Code #Code and run your solution here: ###Output _____no_output_____ ###Markdown Bonus 2 Extra credit (You must complete the regular problems)! Write the VOLUME Function to compute the volume of Cylinders, Spheres, Cones, and Rectangular Boxes. This function should:- First, ask the user about __the shape of the object__ of interest using this statement:*"Please choose the shape of the object. Enter 1 for "Cylinder", 2 for "Sphere", 3 for "Cone", or 4 for "Rectangular Box""*- Second, based on user's choice in the previous step, __ask for the right inputs__.- Third, print out an statement with __the input values and the calculated volumes__. Include error trapping that:1. Issues a message that **"The object should be either a Cylinder, a Sphere, a Cone, or a Rectangular Box. Please Enter A Number from 1,2,3, and 4!"** if the first input is non-numeric.2. Takes any numeric input for the initial selection , and force it into an integer.4. Issues an appropriate message if the user's selection is numeric but outside the range of [1,4]3. Takes any numeric input for the shape characteristics , and force it into a float.4. Issues an appropriate message if the object characteristics are as non-numerics. Test the script for:1. __Sphere, r=10__2. __r=10 , Sphere__3. __Rectangular Box, w=5, h=10, l=0.5__- __Volume of a Cylinder = πr²h__- __Volume of a Sphere = 4(πr3)/3__- __Volume of a Cone = (πr²h)/3__- __Volume of a Rectangular Box = whl__ ###Code #Code and Run your solution here ###Output _____no_output_____
HousePricePredictionDNN.ipynb
###Markdown House Price Prediction with Keras (DNN) Using Pandas and Matplotlib for Exploratory Analysis ###Code import numpy as np import pandas as pd import tensorflow as tf import matplotlib.pyplot as plt import seaborn as sns pd.options.display.max_columns =None training = pd.read_csv("train.csv") testing = pd.read_csv('test.csv') Id = testing[['Id']].values # we need to keep it for the submission file training = training.drop(['Id'],axis = 1) testing = testing.drop(['Id'],axis =1) testing.shape training.shape training.head() training['SalePrice'].describe() sns.distplot(training['SalePrice']) ###Output _____no_output_____ ###Markdown Analyzing Skewness and Kurtosis ###Code print("Skewness: %f" % training['SalePrice'].skew()) print("Kurtosis: %f" % training['SalePrice'].kurt()) The correlation matrix is one of the most useful visualization tools # Correlation Matrix corrmat = training.corr() f,ax = plt.subplots(figsize = (12,9)) sns.heatmap(corrmat,vmax = .8,square = True) # check correlation between sales price and numercial fields # then check for variance between sales price and categorical fields # https://www.kaggle.com/pmarcelino/comprehensive-data-exploration-with-python k = 10 cols = corrmat.nlargest(k,'SalePrice')['SalePrice'].index cm = np.corrcoef(training[cols].values.T) sns.set(font_scale=1.25) hm = sns.heatmap(cm,cbar = True, annot = True, square = True, fmt = '.2f', annot_kws = {'size':10}, yticklabels = cols.values, xticklabels = cols.values) plt.show() ###Output _____no_output_____ ###Markdown The correlation matrix above shows us the top 10 most correlated numerical variables in the dataset.- Look at the variables Garage Cars and Garage Area. We can infer that The amount of cars able to fit in the garage is a consequence of the sqf of the garage. so Lets keep the one with higher correlation.- Drop garage area Selecting Features ###Code # Take only top ten variables correlation coef t_numeric = training[corrmat.nlargest(k,'SalePrice')['SalePrice'].index]# defining column selection t_numeric.head() t_categorical = training.select_dtypes(include= 'object') t_categorical['SalePrice'] = training['SalePrice'] ###Output /Users/franciscoromero/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_indexer,col_indexer] = value instead See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy """Entry point for launching an IPython kernel. ###Markdown The correlation ratio allows us to compute a score describing the relationship between a categorical variable and anumerical one. source: https://towardsdatascience.com/the-search-for-categorical-correlation-a1cf7f1888c9 ###Code def correlation_ratio(categories, measurements): fcat, _ = pd.factorize(categories) cat_num = np.max(fcat)+1 y_avg_array = np.zeros(cat_num) n_array = np.zeros(cat_num) for i in range(0,cat_num): cat_measures = measurements[np.argwhere(fcat == i).flatten()] n_array[i] = len(cat_measures) y_avg_array[i] = np.average(cat_measures) y_total_avg = np.sum(np.multiply(y_avg_array,n_array))/np.sum(n_array) numerator = np.sum(np.multiply(n_array,np.power(np.subtract(y_avg_array,y_total_avg),2))) denominator = np.sum(np.power(np.subtract(measurements,y_total_avg),2)) if numerator == 0: eta = 0.0 else: eta = numerator/denominator return eta for column in t_categorical: if correlation_ratio(t_categorical[column],t_categorical['SalePrice']) > 0.4: print(column) print(correlation_ratio(t_categorical[column],t_categorical['SalePrice'])) # According to this findings we are going to use only this categories in our new dataset t_categorical = t_categorical[['Neighborhood','ExterQual','BsmtQual','KitchenQual']] training = pd.concat([t_numeric,t_categorical],axis =1) training.head() training.shape testing.shape ###Output _____no_output_____ ###Markdown Handling Missing Data ###Code # Keep in mind that this data set has many features and some of them have most of their data missing # In this case we are going to handle missing data in a simple way. total = training.isnull().sum().sort_values(ascending=False) percent = (training.isnull().sum()/training.isnull().count()).sort_values(ascending=False) missing_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent']) missing_data.head(30) # We can see the features with the most missing values # Folowing the kaggle article "Comprehensive Data Exploration with Python" # eliminate columns that have more than 1 data missing # this is a simple but not the best approach since with some extra work filling missing values in the correct way # can help with increasing the accuracy of the model # below are out selected features and correspoding missing values # Drop the columns containing more than one missing value # you can choose to leave it and fill the missing fata with the mode since less than 15% is missing training= training.drop((missing_data[missing_data['Total']>1]).index,1) training.isnull().sum().max() training.head() testing.shape # for the test data I will remove the comlums that were removed from the training data. We need to do this # since out model needs the same features to predeict the prices. Y_training = training[['SalePrice']] # Our label training = training.drop(['SalePrice'],axis = 1) # our Features mylist = training.columns # columns that we want to keep in the testing data mylist = mylist.values testing = testing[mylist] # filter testing data to have only the desired columns testing.isna().sum() # check for null values again #For this test I will just drop those columns testing['KitchenQual']=testing['KitchenQual'].fillna(testing['KitchenQual'].mode()[0]) testing['TotalBsmtSF'] =testing['TotalBsmtSF'].fillna(testing['TotalBsmtSF'].mean()) testing.drop(['GarageArea'], axis =1, inplace =True) training.drop(['GarageArea'], axis = 1, inplace = True) testing['GarageCars'] =testing['GarageCars'].fillna(testing['GarageCars'].mode()[0]) testing.shape training.shape Y_training.shape Id.shape ###Output _____no_output_____ ###Markdown Dummy Variables: Dumies allow our model to better interpret categorical variables by converting them insimple (1,0) variables. e.g A categorical column with 3 categories such as: low medium high will be converted into 3 new comlumns where1 will indicate the precense of such category and 0 its absence. ###Code # Getting Dummy variables for the model to be processed by our neural net training = pd.get_dummies(training) testing = pd.get_dummies(testing) # Check the head and notice the one hot (dummies) as explained above training.head() # Check the head of testing too. testing.head() # Notice that I check the shape repeteadly. I do this to track any mistake when handling the data set # In case of a shape discrepancy I will go back to see what I did wrong. testing.shape training.shape ###Output _____no_output_____ ###Markdown Scaling The Data ###Code ## Convert the train and test data in to np arrays to work as input for the neural net # Traininng data X and Y X_training = training.values X_training = X_training.astype(np.float) Y_training = Y_training.values Y_training = Y_training.astype(np.float) # Testing Data X there is no Y since it is what we want to predict X_testing = testing.values X_testing = X_testing.astype(np.float) ###Output _____no_output_____ ###Markdown Using MinMax Scaler or Standard Scaker from scikit learn package makes it easy to normalize our data ###Code from sklearn.preprocessing import MinMaxScaler X_scaler = MinMaxScaler(feature_range=(0,1)) Y_scaler = MinMaxScaler(feature_range=(0,1)) X_scaled_training = X_scaler.fit_transform(X_training) Y_scaled_training = Y_scaler.fit_transform(Y_training) X_scaled_testing = X_scaler.transform(X_testing) # To scale the data back we need to keep this constants print(Y_scaler.scale_[0], Y_scaler.min_[0]) # Checking the shape of X and Y they must have the same number of rows X_scaled_training.shape Y_scaled_training.shape X_scaled_testing.shape ###Output _____no_output_____ ###Markdown Building The Model Keras a high level API written on top of TensorFlow and it is extremely beginner friendly. It has built in layers, activation functions optimizers and performance metrics and it works like a charm.To begin you can import from tensorflow.keras layers, this will make your code look a little cleaner. ###Code from tensorflow.keras import layers ###Output _____no_output_____ ###Markdown For this regression problem we are going to use fully connected layers in other words "Dense" layers.Activation function ReLu which means Rectified Linear units ###Code def build_model(): model = tf.keras.Sequential([ layers.Dense(256, activation='relu',input_shape=[41]), layers.Dense(128,activation = 'relu'), layers.Dense(64,activation = 'relu'), layers.Dense(1, activation = 'linear') ]) optimizer = tf.keras.optimizers.Adam() model.compile(optimizer = optimizer , loss = 'mse', metrics =['mae','mse']) return model model= build_model() model.summary() ###Output Model: "sequential_1" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_4 (Dense) (None, 256) 10752 _________________________________________________________________ dense_5 (Dense) (None, 128) 32896 _________________________________________________________________ dense_6 (Dense) (None, 64) 8256 _________________________________________________________________ dense_7 (Dense) (None, 1) 65 ================================================================= Total params: 51,969 Trainable params: 51,969 Non-trainable params: 0 _________________________________________________________________ ###Markdown Fitting The Model ###Code from tensorflow import keras import tensorflow_docs as tfdocs import tensorflow_docs.plots import tensorflow_docs.modeling # Early stoping helps prevent overfitting by stoping training when the validation score does not improve # patience means the amount of epochs that have to elapse w/o improvement for the call back to stop the training early_stop = keras.callbacks.EarlyStopping(monitor = 'val_loss',patience = 20) history = model.fit(X_scaled_training,Y_scaled_training,epochs = 500, validation_split = 0.2,verbose =2, callbacks = [tfdocs.modeling.EpochDots()] ) # Visualize Training progress hist = pd.DataFrame(history.history) hist['epoch'] = history.epoch hist.tail() plotter = tfdocs.plots.HistoryPlotter(smoothing_std=2) plotter.plot({'Basic': history}, metric = "mae") plt.ylim([0, 0.5]) plt.ylabel('MAE [SalePrice]') # test_error_rate = model.evaluate(X_scaled_testing,Y_scaled_training,verbose = 2) # print("The MSE for this data set is: {}".format(test_error_rate)) result = model.predict(X_scaled_testing) result ###Output _____no_output_____ ###Markdown Revert Scaling of The Predicted Results Note above that the results are comming out scaled. To scale back the results to the original scale of the data set we need the Y_scaler we computed earlier. Then, perform the oposite operations to scale back the data. ###Code # re-scale the result to the original values prediction = result + 0.048465490904041106 prediction = prediction / 1.3886960144424386e-06 prediction prediction.shape Id.shape ###Output _____no_output_____ ###Markdown Creating The Submission File ###Code sub_df = pd.DataFrame({'Id':Id[:,0],'SalePrice':prediction[:,0]}) sub_df.isnull().sum() sub_df.to_csv('Kaggle_House_Price_NN_13.csv',index = False) ###Output _____no_output_____
notebooks/stack_models-Copy1.ipynb
###Markdown Base models ###Code lasso = make_pipeline(RobustScaler(), Lasso(alpha =0.005, random_state=1,max_iter = 2000)) ENet = make_pipeline(RobustScaler(), ElasticNet(alpha=0.01, l1_ratio=.9, random_state=3)) CatBoost = CatBoostRegressor(loss_function='MAE',random_seed =123,learning_rate=0.1,max_depth=8,task_type='GPU',od_type = 'Iter',od_wait= 15,iterations = 2000) model_xgb = xgb.XGBRegressor(colsample_bytree=0.4603, gamma=0.0468, learning_rate=0.15, max_depth=12, n_estimators=500, reg_alpha=0.4, reg_lambda=0.8, subsample=0.5, silent=1, random_state =7, nthread = -1) model_lgb = lgb.LGBMRegressor(objective='mae',num_leaves=5, learning_rate=0.15, n_estimators=500, bagging_fraction = 0.8, bagging_freq = 5, feature_fraction = 0.2319, feature_fraction_seed=9 ) param_grids = {'n_estimators': 1000, 'max_features': 0.8, # tuned 'max_depth': 14, # tuned } model_qrf = RandomForestQuantileRegressor(**param_grids, criterion = 'mae', n_jobs = -1, random_state =123) n_folds = 5 def rmsle_cv(model,cv = None,X=None,y=None): if cv is None: cv = KFold(n_folds, shuffle=False, random_state=42).get_n_splits(X.values) score = make_scorer(mase,greater_is_better=False) #rmse= np.sqrt(-cross_val_score(model, X.values, y.values.reshape(-1,1), scoring=score, cv = cv)) rmse= cross_val_score(model, X.values, y.values.reshape(-1,), scoring=score, cv = cv) return(rmse) def rmsle_cv_gen(model,cv = None): if cv is None: cv = KFold(n_folds, shuffle=True, random_state=42).get_n_splits(X.values) scores = [] for fold_n, (train_index, valid_index) in enumerate(cv.split(X,fixed_length=False, train_splits=train_splits, test_splits=test_splits)): # print('Fold', fold_n, 'started at', time.ctime()) X_train, X_valid = X.iloc[train_index], X.iloc[valid_index] y_train, y_valid = y.iloc[train_index], y.iloc[valid_index] model.fit(X_train,y_train) preds = model.predict(X_valid) score_val = mase(preds,y_valid) # print(f'Fold {fold_n}. Score: {score_val:.4f}.') print('') scores.append(score_val) #print(f'CV mean score: {np.mean(scores):.4f}, std: {np.std(scores):.4f}.') return(np.array(scores)) class StackingAveragedModels(BaseEstimator, RegressorMixin, TransformerMixin): def __init__(self, base_models, meta_model, n_folds=5): self.base_models = base_models self.meta_model = meta_model self.n_folds = n_folds # We again fit the data on clones of the original models def fit(self, X, y): self.base_models_ = [list() for x in self.base_models] self.meta_model_ = clone(self.meta_model) kfold = KFold(n_splits=self.n_folds, shuffle=True, random_state=156) # Train cloned base models then create out-of-fold predictions # that are needed to train the cloned meta-model out_of_fold_predictions = np.zeros((X.shape[0], len(self.base_models))) for i, model in enumerate(self.base_models): for train_index, holdout_index in kfold.split(X, y): instance = clone(model) self.base_models_[i].append(instance) instance.fit(X[train_index], y[train_index]) y_pred = instance.predict(X[holdout_index]) out_of_fold_predictions[holdout_index, i] = y_pred # Now train the cloned meta-model using the out-of-fold predictions as new feature self.meta_model_.fit(out_of_fold_predictions, y) return self #Do the predictions of all base models on the test data and use the averaged predictions as #meta-features for the final prediction which is done by the meta-model def predict(self, X): meta_features = np.column_stack([ np.column_stack([model.predict(X) for model in base_models]).mean(axis=1) for base_models in self.base_models_ ]) return self.meta_model_.predict(meta_features) score = rmsle_cv(lasso,cv = cv) print("\nLasso score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(lasso) print("\nLasso score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(ENet,cv=cv) print("ElasticNet score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(ENet,cv=None) print("ElasticNet score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(GBoost,cv=cv) print("Gradient Boosting score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(GBoost) print("Gradient Boosting score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(model_xgb,cv=cv) print("Xgboost score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(model_xgb) print("Xgboost score: {:.4f} ({:.4f})\n".format(score.mean(), score.std())) score = rmsle_cv(model_lgb,cv=cv) print("LGBM score: {:.4f} ({:.4f})\n" .format(score.mean(), score.std())) score = rmsle_cv(model_lgb) print("LGBM score: {:.4f} ({:.4f})\n" .format(score.mean(), score.std())) score = rmsle_cv(model_qrf,cv=cv) print("QRFscore: {:.4f} ({:.4f})\n" .format(score.mean(), score.std())) score = rmsle_cv(model_qrf) print("QRF score: {:.4f} ({:.4f})\n" .format(score.mean(), score.std())) pool = Pool(X, y) params = {'iterations': 3000, 'loss_function': 'MAE', 'verbose': False, "random_seed":123, "learning_rate":0.1, "max_depth":8, "task_type":'GPU', "od_type" : 'Iter', "od_wait": 15 } scores = cv(pool, params) #print("Catboostmodels score: {:.4f} ({:.4f})".format(scores.mean(), scores.std())) scores.tail() stacked_averaged_models = StackingAveragedModels(base_models = (ENet, lasso,model_xgb), meta_model = lasso) score = rmsle_cv(stacked_averaged_models) print("Stacking Averaged models score: {:.4f} ({:.4f})".format(score.mean(), score.std())) ###Output C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) C:\Users\abiryukov\AppData\Local\Continuum\anaconda3\envs\ocp\lib\site-packages\sklearn\linear_model\coordinate_descent.py:492: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Fitting data with very small alpha may cause precision problems. ConvergenceWarning) ###Markdown Pull the TPOT models as basic models, attach QRF and do a stacking prediction ###Code pipe_a = exported_pipeline = make_pipeline( make_union( FunctionTransformer(copy,validate=False), MinMaxScaler() ), StackingEstimator(estimator=ExtraTreesRegressor(bootstrap=True, max_depth=5, max_features=0.15000000000000002, min_samples_leaf=0.055, min_samples_split=0.505, n_estimators=100)), StackingEstimator(estimator=ExtraTreesRegressor(bootstrap=False, max_depth=9, max_features=0.15000000000000002, min_samples_leaf=0.255, min_samples_split=0.005, n_estimators=100)), StackingEstimator(estimator=ExtraTreesRegressor(bootstrap=True, max_depth=5, max_features=0.35000000000000003, min_samples_leaf=0.20500000000000002, min_samples_split=0.35500000000000004, n_estimators=250)), LGBMRegressor(colsample_bytree=0.75, learning_rate=0.01, max_bin=127, max_depth=4, min_child_weight=15, n_estimators=300, num_leaves=90, objective="fair", reg_alpha=0.05, subsample=0.75, subsample_freq=0, verbosity=-1,n_thread=-1) ) pipe_b = make_pipeline( StackingEstimator(estimator=ExtraTreesRegressor(bootstrap=True, max_depth=4, max_features=0.5500000000000002, min_samples_leaf=0.055, min_samples_split=0.455, n_estimators=300)), MinMaxScaler(), StackingEstimator(estimator=ExtraTreesRegressor(bootstrap=True, max_depth=5, max_features=0.5500000000000002, min_samples_leaf=0.255, min_samples_split=0.20500000000000002, n_estimators=500)), LGBMRegressor(colsample_bytree=1.0, learning_rate=0.2, max_bin=63, max_depth=4, min_child_weight=0.001, n_estimators=250, num_leaves=90, objective="huber", reg_alpha=0.007, subsample=0.8, subsample_freq=0, verbosity=-1,n_thread=-1) ) pipe_c = exported_pipeline = make_pipeline( make_union( FunctionTransformer(copy,validate=False), make_union( FunctionTransformer(copy,validate=False), FunctionTransformer(copy,validate=False) ) ), StackingEstimator(estimator=LGBMRegressor(colsample_bytree=1.0, learning_rate=0.005, max_bin=127, max_depth=5, min_child_weight=1, n_estimators=250, num_leaves=100, objective="mape", reg_alpha=0.01, subsample=0.7, subsample_freq=10, verbosity=-1)), LGBMRegressor(colsample_bytree=1.0, learning_rate=0.001, max_bin=127, max_depth=4, min_child_weight=10, n_estimators=300, num_leaves=70, objective="mape", reg_alpha=0.05, subsample=0.9, subsample_freq=30, verbosity=-1,n_thread=-1) ) stacked_averaged_models = StackingAveragedModels(base_models = (pipe_a, pipe_b,pipe_c,model_xgb), meta_model = ENet) score = rmsle_cv(stacked_averaged_models) print("Stacking Averaged models score: {:.4f} ({:.4f})".format(score.mean(), score.std())) print("Stacking Averaged models score: {:.4f} ({:.4f})".format(score.mean(), score.std())) ###Output Stacking Averaged models score: -3.3235 (0.3430) ###Markdown Final predictions: ###Code from scipy.stats import boxcox from scipy.special import inv_boxcox preds_all = [] for year in [2016,2017]: print(year) data_dict = pd.read_pickle(f'../data/processed/data_dict_all.pkl') X_test = data_dict[year]['X_test_ts'].copy() tgt = "rougher.output.recovery" X = data_dict[year]['X_train_ts'].copy() print(f'1) Test shape: {X_test.shape}, train: {X.shape}') y = data_dict[year]['y_train'][tgt].dropna() y = y[(y>5) & (y <100)] inds = X.index.intersection(y.index) X = X.loc[inds] y = y.loc[inds] stacked_averaged_models.fit(X.values, y) ypred_r = stacked_averaged_models.predict(X_test.values) preds_r = pd.DataFrame(data = {'date':X_test.index, tgt:ypred_r}).set_index('date') tgt = "final.output.recovery" print(f'2) Test shape: {X_test.shape}, train: {X.shape}') X = data_dict[year]['X_train_ts'].copy() X_test = data_dict[year]['X_test_ts'].copy() y = data_dict[year]['y_train'][tgt].dropna() y = y[(y>5) & (y <100)] inds = X.index.intersection(y.index) X = X.loc[inds] y = y.loc[inds] print(f'3) Test shape: {X_test.shape}, train: {X.shape}') stacked_averaged_models.fit(X.values, y) ypred_f = stacked_averaged_models.predict(X_test.values) preds_f = pd.DataFrame(data = {'date':X_test.index, tgt:ypred_f}).set_index('date') preds_all.append(preds_r.join(preds_f)) stacked_preds_sub = pd.concat(preds_all) stacked_preds_sub = stacked_preds_sub.reset_index() stacked_preds_sub['date'] = stacked_preds_sub['date'].dt.strftime('%Y-%m-%dT%H:%M:%SZ') stacked_preds_sub.set_index('date',inplace=True) stacked_preds_sub.drop_duplicates(inplace=True) stacked_preds_sub.to_csv('../results/stacked_sub_3_window.csv') ypred_r ###Output _____no_output_____
tensorflow_1_x/7_kaggle/notebooks/sql/raw/ex2_select.ipynb
###Markdown IntroTry some **SELECT** statements of your own to see if you can answer the questions from a large dataset of air pollution measurements.Again, run the cell below to set everything up. ###Code # Set up feedack system from learntools.core import binder binder.bind(globals()) from learntools.sql.ex2 import * # import package with helper functions import bq_helper # create a helper object for this dataset open_aq = bq_helper.BigQueryHelper(active_project="bigquery-public-data", dataset_name="openaq") print("Setup Complete") # print list of tables in this dataset (there's only one!) print('Tables list: {}'.format(open_aq.list_tables())) # print look at top few rows open_aq.head('global_air_quality') ###Output _____no_output_____ ###Markdown Now you'll write and run the code to answer the questions below. Question 1) Which countries have reported pollution levels in units of "ppm"? In case it's useful to see an example query, here's some code from the tutorial:```query = """SELECT city FROM `bigquery-public-data.openaq.global_air_quality` WHERE country = 'US' """open_aq.query_to_pandas_safe(query)``` ###Code # Your Code Goes Here first_query = ____ first_results = open_aq.query_to_pandas_safe(first_query) # View top few rows of results print(first_results.head()) q_1.check() ###Output _____no_output_____ ###Markdown For the solution, uncomment the line below. ###Code #q_1.solution() ###Output _____no_output_____ ###Markdown 2) Select all columns of the rows where pollution levels were reported to be exactly 0? ###Code # Your Code Goes Here zero_pollution_query = ____ zero_pollution_results = ____ print(zero_pollution_results.head()) q_2.check() ###Output _____no_output_____ ###Markdown For the solution, uncomment the line below: ###Code #q_2.solution() ###Output _____no_output_____
notebooks/truth_match_table.ipynb
###Markdown Rubin LSST DESC DC2: Accessing Truth-match Table with GCRCatalogs**Authors**: Yao-Yuan Mao (@yymao), Javier Sanchez (@fjaviersanchez), Joanne Bogart (@JoanneBogart)This notebook will illustrate the basics of accessing the Truth-match Table, which contains the basic properties of truth objects (i.e., inputs to the image simulations) and also matching information with respect to the Object Table.**Prerequisite**: Please go over the Object Table tutorial first! **Learning objectives**: After going through this notebook, you should be able to: 1. Load and efficiently access a DC2 Truth-match Table with the GCRCatalogs 2. Understand and have references for the Truth-match Table schema and data model 3. Make some validation plots using the Truth-match Table Before you startMake sure you have followed the instructions [here](https://lsstdesc.org/DC2-Public-Release/) to download the data files, install `GCRCatalogs`, and set up `root_dir` for `GCRCatalogs`. Import necessary packages ###Code import numpy as np import matplotlib.pyplot as plt %matplotlib inline import GCRCatalogs from GCRCatalogs.helpers.tract_catalogs import tract_filter, sample_filter from GCRCatalogs import GCRQuery ###Output _____no_output_____ ###Markdown Access Truth-match Table with GCRCatalogsJust like the Object Table, the Truth-match Table is available as parquet files, and `GCRCatalogs` provides a high-level user interface for accessing it. However, while the Truth-match Table is a single set of parquet files, it appears as two entries in `GCRCatalogs` as we will see below. - The catalog entry `desc_dc2_run2.2i_dr6_truth` contains all truth information, including true sources that are not detected in the DR6 Object Table. - The catalog entry `desc_dc2_run2.2i_dr6_object_with_truth_match` contains all the identical information of the Object Table (`desc_dc2_run2.2i_dr6_object`), plus additional columns that contain information of best-match truth objects. In other words, `desc_dc2_run2.2i_dr6_object_with_truth_match` is like a "left join" of `desc_dc2_run2.2i_dr6_object` and `desc_dc2_run2.2i_dr6_truth`, but with spatial separation and magnitude difference as join keys. See the release note for further details. Which catalog entry should I use?- If you don't need any truth information, just use `desc_dc2_run2.2i_dr6_object`. - If you only need the best-match truth source information for each object (i.e., each row) in the Object Table, use `desc_dc2_run2.2i_dr6_object_with_truth_match`- If you need more truth infomation beyond the best matches (i.e., undetected sources, blended sources), you need to use `desc_dc2_run2.2i_dr6_truth` ###Code GCRCatalogs.get_public_catalog_names() object_cat = GCRCatalogs.load_catalog('desc_dc2_run2.2i_dr6_object') match_cat = GCRCatalogs.load_catalog('desc_dc2_run2.2i_dr6_object_with_truth_match') truth_cat = GCRCatalogs.load_catalog('desc_dc2_run2.2i_dr6_truth') ###Output _____no_output_____ ###Markdown Let's first take a look at `match_cat` (which loads `desc_dc2_run2.2i_dr6_object_with_truth_match`). As discussed earlier, this catalog is just Object Table plus best match truth information. We can check if all the columns in the Object Table are present in this catalog too. ###Code set(object_cat.list_all_quantities()).issubset(match_cat.list_all_quantities()) ###Output _____no_output_____ ###Markdown Indeed `match_cat` contains all columns in the Object Table. So what are the additional columns? ###Code set(match_cat.list_all_quantities()).difference(object_cat.list_all_quantities()) ###Output _____no_output_____ ###Markdown These columns describe the infomation of the matched truth source for each object in the Object Table. Note that most of these columns have a `_truth` postfix (i.e., suffix) to avoid potential confusion with columns in the Object Table.In fact, these columns are the same set of columns in `truth_cat` (but there's no `_truth` postfix in `truth_cat`): ###Code sorted(truth_cat.list_all_quantities()) # We can verify what we just said is indeed true: additional_cols_in_match = set(match_cat.list_all_quantities()).difference(object_cat.list_all_quantities()) set(col[:-6] if col.endswith("_truth") else col for col in additional_cols_in_match) == set(truth_cat.list_all_quantities()) ###Output _____no_output_____ ###Markdown What are "best matches"?Recall that `match_cat` is a "left join" of Object Table and Truth Table, so each object is assigned a "best match" truth source.A "best match" truth source is the truth source that is within 1 arcsec of the object in consideration, and has the smallest magnitude difference.If there's no truth sources that are within 1 arcsec of the object in consideration, or if the smallest magnitude difference is larger than 1 mag, then the "best match" would be just the nearest neighbor. If a best match satisfies the two criteria (separation < 1 arcsec and magnitude difference < 1 mag), we call it a "good match". Otherwise, it would just be the nearest neighbor. Note that a "good match" could still (in fact, is likely to) be the nearest neighbor. Let's take a closer look. We can use the `is_good_match` and `is_nearest_neighbor` to tell whether the best match is a good match and/or the nearest neighbor. ###Code data = match_cat.get_quantities(["mag_r_cModel", "mag_r_truth", "match_sep", "is_good_match", "is_nearest_neighbor"], native_filters=[tract_filter(3830)]) # Note that if the best match is not a good match, then it must be the nearest neighbor. (data["is_good_match"] | data["is_nearest_neighbor"]).all() # Most "good matches" (sep. < 1 arcsec, dmag < 1 mag) would also happen to be nearest neighbors (NN). # "Not good" matches can be due to either large separation or large magnitude difference. # Let's define a few masks to distinguish these cases: dmag = np.abs(data["mag_r_truth"] - data["mag_r_cModel"]) good_and_nn = data["is_good_match"] & data["is_nearest_neighbor"] # Good matches that happen to be the nearest neighbor (NN) too good_not_nn = data["is_good_match"] & (~data["is_nearest_neighbor"]) # Good matches that are not the nearest neighbor (NN) not_good_small_dmag = (~data["is_good_match"]) & (dmag < 1) # Not good matches that have dmag < 1 mag (so they must have sep > 1 arcsec) not_good_large_dmag = (~data["is_good_match"]) & ((dmag >= 1) | np.isnan(dmag)) # Not good matches that have dmag > 1 mag or undefined mag # These four masks are mutually exclusive: (np.vstack([good_and_nn, good_not_nn, not_good_small_dmag, not_good_large_dmag]).astype(np.int).sum(axis=0) == 1).all() sep_bins = np.linspace(0, 5, 51) fig, ax = plt.subplots(ncols=2, figsize=(10, 4), dpi=100) hist = ax[0].hist(data["match_sep"], bins=sep_bins)[0] ax[0].set_yscale("log"); ax[0].set_xlabel("separation [arcsec]"); ax[0].set_ylabel("number (per bin)"); bottom = None for mask, color in zip( [good_and_nn, good_not_nn, not_good_small_dmag, not_good_large_dmag], [plt.cm.Greens(0.8), plt.cm.Greens(0.4), plt.cm.Oranges(0.4), plt.cm.Oranges(0.8)] ): frac = np.histogram(data["match_sep"][mask], bins=sep_bins)[0] / hist ax[1].bar(sep_bins[:-1], frac, width=np.ediff1d(sep_bins), bottom=bottom, align="edge", color=color) if bottom is None: bottom = frac else: bottom += frac ax[1].set_xlabel("separation [arcsec]"); ax[1].set_ylabel("fraction (per bin)"); ###Output _____no_output_____ ###Markdown In the figure above, the left panel shows the distribution of spatial separation for all best matches (note that y-axis is in log scale). The vast majority of objects have matches within 1 arcsec, with a small tail goes to up to 5 arcsec. The right panel shows that, in each bin of spatial separation, the fraction of the four situations that we defined early. The greens bars denote "good matches" (sep. < 1 arcsec and dmag < 1 mag), and we can see that the majority of "good matches" are also nearest neighbor (darker green), especially if the separation is small. The oranges bars denote "not good matches" (so that they are all nearest neighbors by definition).About only 20% of these nearest neighbors but not good matches have close magnitude (dmag < 1 mag). Let's also look at the measured vs. true magnitudes for these different matches. ###Code fig, ax = plt.subplots(2, 2, figsize=(8, 8), dpi=100) for mask, color, label, ax_this in zip( [good_and_nn, good_not_nn, not_good_small_dmag, not_good_large_dmag], [plt.cm.Greens(0.8), plt.cm.Greens(0.4), plt.cm.Oranges(0.4), plt.cm.Oranges(0.8)], ["good match\nnearest neighbor", "good match\nnot nearest neighbor", "not good match\nnearest neighbor\ndmag < 1", "not good match\nnearest neighbor\ndmag > 1"], ax.flat ): ax_this.scatter(data["mag_r_truth"][mask], data["mag_r_cModel"][mask], color=color, s=0.005, rasterized=True) ax_this.set_xlim(15, 35) ax_this.set_ylim(15, 35) ax_this.plot([15, 35], [15, 35], color='grey', lw=0.5) ax_this.text(16, 34, label, va="top") fig.text(0.5, 0.02, "true r-band mag", ha="center"); fig.text(0.02, 0.5, "measured r-band mag", va="center", rotation=90); ###Output _____no_output_____ ###Markdown Note that because `match_cat` uses the Object Table as the reference catalog for the match, a unique truth source may appear twice in the catalog. ###Code truth_id = match_cat.get_quantities(["id_truth"], native_filters=tract_filter(3830))["id_truth"] number_of_objects = len(truth_id) number_of_unique_truth = len(np.unique(truth_id)) print("Number of objects", number_of_objects) print("Number of unique truth sources", number_of_unique_truth) ###Output _____no_output_____ ###Markdown Truth TableNow we switch to look at the full truth table `truth_cat`. When using `truth_cat`, you will obtain all truth sources, including those below the detection limit or blended. You will also obtain only *unique* truth sources (unlike the case of `match_cat` as we shown above). The Truth Table allows us to inspect, for example, undetected sources. Here, let's look at how many truth galaxies are detected (and not blended) as a function of the galaxy magnitude. To select only galaxies, we can filter on `truth_type == 1`. Here the truth type is 1 for galaxies, 2 for stars, and 3 for SNe. ###Code truth_galaxies = truth_cat.get_quantities( quantities=["match_objectId", "is_good_match", "mag_r"], filters=["truth_type == 1"], native_filters=[tract_filter(3830)], ) mag_bins = np.linspace(14.5, 29.5, 46) fig, ax = plt.subplots(figsize=(6,4), dpi=100) ax.hist(truth_galaxies["mag_r"][truth_galaxies["is_good_match"]], mag_bins, histtype="step", label="has good match", lw=1.5, color="C2"); ax.hist(truth_galaxies["mag_r"][(~truth_galaxies["is_good_match"]) & (truth_galaxies["match_objectId"] > -1)], mag_bins, histtype="step", label="has NN (but not good) match", lw=1.5, color="C1"); ax.hist(truth_galaxies["mag_r"][truth_galaxies["match_objectId"] == -1], mag_bins, histtype="step", label="has no matches at all", lw=1.5, color="C3"); ax.set_yscale("log"); ax.legend(loc="upper left"); ax.set_xlabel("r-band mag"); ax.set_ylabel("number per bin"); ax.set_xticks(np.arange(14, 31)); ###Output _____no_output_____ ###Markdown From the plot above, we see that at around $r = 27$, about half of the sources are "detected", in the sense that a good match in the Object Table is found. Much more sources fainter than $r = 27$ are not detected (or a match is not found). On the bright end, the vast majority have good matches. A handful cases where there is no good matches or no matches are interesting blending study cases.Finally, recall that in the Object Table tutorial, we looked at the galaxy number density function. We can now compare the truth galaxy number density function with the measured one! We will mostly follow the same procedure as in the Object Table tutorial. We will estimate the sky area assuming a rectangular geometry of a single tract. ###Code truth_galaxies = truth_cat.get_quantities( quantities=["mag_i", "ra", "dec"], filters=["truth_type == 1"], native_filters=[tract_filter(3830)], ) measured_galaxies = object_cat.get_quantities( quantities=["mag_i_cModel"], filters=["extendedness == 1", "clean", (np.isfinite, "mag_i_cModel")], native_filters=[tract_filter(3830)], ) d_ra = truth_galaxies["ra"].max() - truth_galaxies["ra"].min() d_dec = truth_galaxies["dec"].max() - truth_galaxies["dec"].min() cos_dec = np.cos(np.deg2rad(np.median(truth_galaxies["dec"]))) sky_area_sq_arcmin = (d_ra * cos_dec * 60) * (d_dec * 60) print(sky_area_sq_arcmin) mag_bins = np.linspace(15, 30, 51) cdf_truth = np.searchsorted(truth_galaxies["mag_i"], mag_bins, sorter=truth_galaxies["mag_i"].argsort()) cdf_measured = np.searchsorted(measured_galaxies["mag_i_cModel"], mag_bins, sorter=measured_galaxies["mag_i_cModel"].argsort()) fig, ax = plt.subplots(2, sharex=True, figsize=(6,5), gridspec_kw={"hspace": 0, "height_ratios": (3,1)}, dpi=100) ax[0].semilogy(mag_bins, cdf_measured / sky_area_sq_arcmin, label="Measured") ax[0].semilogy(mag_bins, cdf_truth / sky_area_sq_arcmin, label="Truth", ls="--") ax[1].set_xlabel("$i$-band cModel mag"); ax[0].set_ylabel("Cumulative number per sq. arcmin"); ax[1].semilogy(mag_bins, cdf_measured/cdf_truth) ax[1].set_ylim(0.5, 2) ax[0].legend(); ax[0].grid(); # add grid to guide our eyes ax[1].grid(); ###Output _____no_output_____
notebooks_paper_2021/Results/results_embeddings.ipynb
###Markdown Embedding effect on ESN - IMDB dataset Librairies ###Code import io import os import re import sys import pickle import time from timeit import default_timer as timer import numpy as np import random import torch import torch.nn as nn import torch.optim as optim from datasets import load_dataset, Dataset, concatenate_datasets from transformers import AutoTokenizer from transformers import BertModel from transformers.data.data_collator import DataCollatorWithPadding import esntorch.core.reservoir as res import esntorch.core.learning_algo as la import esntorch.core.merging_strategy as ms import esntorch.core.esn as esn device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') device ###Output _____no_output_____ ###Markdown Dataset ###Code # rename correct column as 'labels': depends on the dataset you load def load_and_enrich_dataset(dataset_name, split, cache_dir): dataset = load_dataset(dataset_name, split=split, cache_dir=CACHE_DIR) dataset = dataset.rename_column('label', 'labels') # cf 'imdb' dataset dataset = dataset.map(lambda e: tokenizer(e['text'], truncation=True, padding=False), batched=True) dataset.set_format(type='torch', columns=['input_ids', 'attention_mask', 'labels']) def add_lengths(sample): sample["lengths"] = sum(sample["input_ids"] != 0) return sample dataset = dataset.map(add_lengths, batched=False) return dataset CACHE_DIR = '~/Data/huggignface/' # put your own path here tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') full_train_dataset = load_and_enrich_dataset('imdb', split='train', cache_dir=CACHE_DIR).sort("lengths") # toriving/sst5 train_val_datasets = full_train_dataset.train_test_split(train_size=0.8, shuffle=True) train_dataset = train_val_datasets['train'].sort("lengths") val_dataset = train_val_datasets['test'].sort("lengths") test_dataset = load_and_enrich_dataset('imdb', split='test', cache_dir=CACHE_DIR).sort("lengths") dataset_d = { 'full_train': full_train_dataset, 'train': train_dataset, 'val': val_dataset, 'test': test_dataset } dataloader_d = {} for k, v in dataset_d.items(): dataloader_d[k] = torch.utils.data.DataLoader(v, batch_size=128,#256, reduced for bi-direction collate_fn=DataCollatorWithPadding(tokenizer)) dataset_d ###Output _____no_output_____ ###Markdown Model ###Code # results acc_l = [] time_l = [] # loop over seeds for seed in [7, 1949, 1947, 1979, 1983]: print('\n SEED: {}'.format(seed)) # model params esn_params = { 'embedding_weights': 'bert-base-uncased', 'distribution' : 'uniform', 'input_dim' : 768, 'reservoir_dim' : 500, 'bias_scaling' : 1.0, 'sparsity' : 0.99, 'spectral_radius' : 0.6, 'leaking_rate': 0.8, 'activation_function' : 'tanh', 'input_scaling' : 0.5, 'mean' : 0.0, 'std' : 1.0, 'learning_algo' : None, 'criterion' : None, 'optimizer' : None, 'merging_strategy' : 'mean', 'lexicon' : None, 'bidirectional' : False, 'device' : device, # this is new 'seed' : seed } # model ESN = esn.EchoStateNetwork(**esn_params) ESN.learning_algo = la.RidgeRegression(alpha=16)# , mode='normalize') ESN = ESN.to(device) # warm up (new) nb_sentences = 3 for i in range(nb_sentences): sentence = dataset_d["train"].select([i]) dataloader_tmp = torch.utils.data.DataLoader(sentence, batch_size=1, collate_fn=DataCollatorWithPadding(tokenizer)) for sentence in dataloader_tmp: ESN.warm_up(sentence) # train t0 = timer() LOSS = ESN.fit(dataloader_d["full_train"]) # changed back full_train => train t1 = timer() time_l.append(t1 - t0) # predict acc = ESN.predict(dataloader_d["test"], verbose=False)[1].item() # results acc_l.append(acc) # delete objects del ESN.learning_algo del ESN.criterion del ESN.merging_strategy del ESN torch.cuda.empty_cache() acc_l2 = [88.37999725341797, 88.4280014038086, 88.50399780273438, 88.4959945678711, 88.2239990234375] time_l2 = [172.32195102376863, 174.07607653178275, 174.04811804788187, 173.9174865661189, 174.44320438290015] ###Output _____no_output_____ ###Markdown Plot ###Code with open('embedding_results.pkl', 'rb') as fh: acc_raw_d = pickle.load(fh) # Take 5 samples out of 10 acc_d = {} for k, v in acc_raw_d.items(): ints_l = random.sample(range(0, 10), 5) acc_l = [v[k] for k in ints_l] acc_d[k] = np.mean(acc_l), np.std(acc_l) acc_d # Add BERT results acc_d['bert-base-uncased'] = np.mean(acc_l2), np.std(acc_l2) acc_d acc_d.pop('charngram.100d', None) import matplotlib.pyplot as plt plt.style.use('ggplot') fig, ax = plt.subplots(figsize=(7,3)) acc_l = [v[0] for v in acc_d.values()] std_l = [v[1] for v in acc_d.values()] # ax.errorbar(range(len(acc_d)), acc_l, yerr=std_l, fmt='-', color='C1', linewidth=2) ax.plot(range(len(acc_d)), acc_l, marker='o', color='C1', linewidth=3) # ax.set_title('Test Accuracy of an ESN over IMDB dataset') ax.set_xticks(range(len(acc_d))) ax.set_xticklabels(acc_d.keys(), rotation=45) ax.set_xlabel('Pre-trained embeddings') ax.set_ylabel('Test accuracy') plt.savefig("embeddings.pdf", bbox_inches='tight', dpi=300) plt.show() ###Output _____no_output_____
PythonOverview.ipynb
###Markdown ___ ___ Python Crash CoursePlease note, this is not meant to be a comprehensive overview of Python or programming in general, if you have no programming experience, you should probably take my other course: [Complete Python Bootcamp](https://www.udemy.com/complete-python-bootcamp/?couponCode=PY20) instead.**This notebook is just a code reference for the videos, no written explanations here**This notebook will just go through the basic topics in order:* Data types * Numbers * Strings * Printing * Lists * Dictionaries * Booleans * Tuples * Sets* Comparison Operators* if, elif, else Statements* for Loops* while Loops* range()* list comprehension* functions* lambda expressions* map and filter* methods____ Data types Numbers ###Code 1 + 1 1 * 3 1 / 2 2 ** 4 4 % 2 5 % 2 (2 + 3) * (5 + 5) ###Output _____no_output_____ ###Markdown Loop 10 random s and test for even/odd ###Code from random import randint for i in range(10): rand_num = randint(0, 10000) if rand_num % 2: # we could have written: if rand_num & 2 == 0: print("even: \t", rand_num) # \t is a tab char else: print("odd: \t", rand_num) ###Output odd: 4872 odd: 6880 odd: 4630 odd: 5010 odd: 5416 even: 9083 odd: 3326 odd: 7326 even: 5229 even: 3147 ###Markdown Variable Assignment ###Code # Use lowercase; don't start with number or special characters; separate with _ name_of_var = 2 x = 2 y = 3 z = x + y z ###Output _____no_output_____ ###Markdown Comments Use a single at beginning of line for a comment, or use: 2 spaces + after code, or use: """docstring block of text here more docstring text here a bit more here to explain the code more here and here... """ (end with these followed by a blank line) Strings ###Code 'single quotes' "double quotes" "wrap lot's of other quotes" ###Output _____no_output_____ ###Markdown Printing ###Code x = 'hello' x print(x) num = 12 name = 'Sam' print('My number is: {one}, and my name is: {two}'.format(one=num,two=name)) # advantage with the above method is that you don't have to worry about # the order of 'one' and 'two', and you can use them multiple times, such as below. # Note that you must use legal variable names in the {} print('Number: {one}, name: {two}. And {two} is {one} years old!'.format(one=num, two=name)) print('My number is: {}, and my name is: {}'.format(num,name)) # the above method is certainly the easiest to write and read if you're usinhg # the values only once in a line. You can also do it this way: print('Number: {0}, name: {1}. And {1} is {0} years old!'.format(num, name)) ###Output Number: 12, name: Sam. And Sam is 12 years old! ###Markdown Lists ###Code [1,2,3] ['hi',1,[1,2]] my_list = ['a','b','c', 'd', 'e'] my_list.append('f') # appends single value to the end of the list my_list.insert(5,'Z') # .insert(position_to_insert, value_to_insert) my_list my_list.extend(['j', 'k', 'l']) # add multiple items to your list my_list my_list[0] my_list[1] my_list[-1] my_list[-4:-2] my_list[-3::] my_list[1:] my_list[:3] # ending index number is NOT included my_list[2:5] my_list[0] = 'NEW' my_list my_list[5] = "HOLA!" # or use: my_list.insert(5, 'HOLA!') my_list nest = [1,2,3,[4,5,['target']], 6, 7, ['a', 'b', 'c']] nest[3] nest[-1] nest[3][2] nest[3][2][0] nest[3][2] nest[-1][0] nested = [1, 2, [3, 4, [5, 6, [7, 8]]]] nested[2] nested[2][2] nested[2][2][2] nested[2][2][2][0] ###Output _____no_output_____ ###Markdown Dictionaries ###Code d = {'key1':'item1','key2':'item2'} d d['key1'] ###Output _____no_output_____ ###Markdown Booleans ###Code True False ###Output _____no_output_____ ###Markdown Tuples ###Code t = (1,2,3) t[0] t[0] = 'NEW' ###Output _____no_output_____ ###Markdown Sets ###Code {1,2,3} {1,2,3,1,2,1,2,3,3,3,3,2,2,2,1,1,2} ###Output _____no_output_____ ###Markdown Comparison Operators ###Code 1 > 2 1 < 2 1 >= 1 1 <= 4 1 == 1 'hi' == 'bye' ###Output _____no_output_____ ###Markdown Logic Operators ###Code (1 > 2) and (2 < 3) (1 > 2) or (2 < 3) (1 == 2) or (2 == 3) or (4 == 4) ###Output _____no_output_____ ###Markdown if,elif, else Statements ###Code if 1 < 2: print('Yep!') if 1 < 2: print('yep!') if 1 < 2: print('first') else: print('last') if 1 > 2: print('first') else: print('last') if 1 == 2: print('first') elif 3 == 3: print('middle') else: print('Last') ###Output _____no_output_____ ###Markdown for Loops ###Code seq = [1,2,3,4,5] for item in seq: print(item) for item in seq: print('Yep') for jelly in seq: print(jelly+jelly) ###Output _____no_output_____ ###Markdown while Loops ###Code i = 1 while i < 5: print('i is: {}'.format(i)) i = i+1 ###Output _____no_output_____ ###Markdown range() ###Code range(5) for i in range(5): print(i) list(range(5)) ###Output _____no_output_____ ###Markdown list comprehension ###Code x = [1,2,3,4] out = [] for item in x: out.append(item**2) print(out) [item**2 for item in x] ###Output _____no_output_____ ###Markdown functions ###Code def my_func(param1='default'): """ Docstring goes here. """ print(param1) my_func my_func() my_func('new param') my_func(param1='new param') def square(x): return x**2 out = square(2) print(out) ###Output _____no_output_____ ###Markdown lambda expressions ###Code def times2(var): return var*2 times2(2) lambda var: var*2 ###Output _____no_output_____ ###Markdown map and filter ###Code seq = [1,2,3,4,5] map(times2,seq) list(map(times2,seq)) list(map(lambda var: var*2,seq)) filter(lambda item: item%2 == 0,seq) list(filter(lambda item: item%2 == 0,seq)) ###Output _____no_output_____ ###Markdown methods ###Code st = 'hello my name is Sam' st.lower() st.upper() st.split() tweet = 'Go Sports! #Sports' tweet.split('#') tweet.split('#')[1] d d.keys() d.items() lst = [1,2,3] lst.pop() lst 'x' in [1,2,3] 'x' in ['x','y','z'] ###Output _____no_output_____
part02_SolversII.ipynb
###Markdown Overview of Solvers II Goal- Get an overview of various solvers in Ocean- Understand the main purpose of each solver- Get familiar with some basic solver parameters- Get familiar with embedding ProblemTo focus on sampler, we are going to create a simple BQM problem that we will solve using different solvers. ###Code from dimod import BinaryQuadraticModel, to_networkx_graph bqm = BinaryQuadraticModel('SPIN') bqm.add_variable(0, -1) bqm.add_variable(1, -1) bqm.add_variable(4, -1) bqm.add_variable(5, -1) bqm.add_interaction(0, 4, 1.0) bqm.add_interaction(0, 5, 1.0) bqm.add_interaction(1, 4, 1.0) bqm.add_interaction(1, 5, 1.0) bqm.add_interaction(0, 1, 1.0) bqm.add_interaction(4, 5, 1.0) import networkx as nx nx.draw(to_networkx_graph(bqm)) ###Output _____no_output_____ ###Markdown ExactSolver- Mainly for debugging purposes- Can solve problems with up to 20 variables (or more) depending on the system ###Code from dimod import ExactSolver solver = ExactSolver() response = solver.sample(bqm) print(response.truncate(10)) ###Output _____no_output_____ ###Markdown DWaveSampler- The main interface to use the quantum annealing processor- It can select different quantum processors including the most recent Advantage system- It can solve optimization problems casted as an Ising Hamiltonian- The solver API allow submitting more abstract problems forms such as QUBO and BQM ###Code from dwave.system import DWaveSampler sampler = DWaveSampler(solver=dict(topology__type='chimera')) response = sampler.sample( bqm, num_reads=10, annealing_time=10, auto_scale=False, answer_mode='raw' ) print(response) ###Output _____no_output_____ ###Markdown What happened?- The graph of qubit connectivity is not fully connected. - Some qubit-qubit interactions do not exist- If the problem graph has interactions that don't exist, we cannot solve that problem directly- What should we do? EmbeddingComposite- As mentioned above, the graph of a problem and the processor may not be compatible- One may use a chain of qubits that are strongly connected to act as a single qubit- This is a complicated process that requires an hour long lecture- The `EmbeddingComposite` abstracts away all the complications ###Code from dwave.system import EmbeddingComposite from dwave.system import DWaveSampler sampler = EmbeddingComposite(DWaveSampler(solver=dict(topology__type='chimera'))) response = sampler.sample( bqm, num_reads=10, annealing_time=10, auto_scale=True, answer_mode='raw', return_embedding=True ) print(response) print(response.info.get('embedding_context').get('embedding')) ###Output _____no_output_____ ###Markdown DWaveCliqueSampler- More abstractions- If you have a dense or fully connected problem, it's much better to use a clique sampler than heuristic embedding because heuristic embedding may not find efficient embeddings (e.g. it may find embeddings with larger chains and uneven chain length).- Even more abstraction $\rightarrow$ `DWaveCliqueSampler` is a standalone sampler ###Code from dwave.system import DWaveCliqueSampler sampler = DWaveCliqueSampler() response = sampler.sample( bqm, num_reads=10, annealing_time=10, answer_mode='raw' ) print(response) ###Output _____no_output_____ ###Markdown LeapHybridSampler- The most flexible solver - Can solve large, dense problems efficiently using classical and quantum resources- 20,000 variable fully connected (~200M biases)- 1 million variables with at most 200M biases- Only one parameter - time limit (the minimum time limit is chosen by default) ###Code from dwave.system import LeapHybridSampler sampler = LeapHybridSampler() print(sampler.properties) response = sampler.sample( bqm, time_limit=10, ) print(response) ###Output _____no_output_____
Assign_SVM_Forest_fires.ipynb
###Markdown Problem Statement:classify the Size_Categorie using SVMmonth month of the year: 'jan' to 'dec'day day of the week: 'mon' to 'sun'FFMC FFMC index from the FWI system: 18.7 to 96.20DMC DMC index from the FWI system: 1.1 to 291.3DC DC index from the FWI system: 7.9 to 860.6ISI ISI index from the FWI system: 0.0 to 56.10temp temperature in Celsius degrees: 2.2 to 33.30RH relative humidity in %: 15.0 to 100wind wind speed in km/h: 0.40 to 9.40rain outside rain in mm/m2 : 0.0 to 6.4Size_Categorie the burned area of the forest ( Small , Large) ###Code import pandas as pd import numpy as np from sklearn.svm import SVC import warnings warnings.filterwarnings("ignore") from sklearn.preprocessing import LabelEncoder forest = pd.read_csv("G:/data sceince/Assignments/SVM/forestfires.csv") forest.head() forest.info() forest.dtypes forest.month.unique() # convering the size_category column into Labels by using label encoder label_encoder = LabelEncoder() forest['size_category'] = label_encoder.fit_transform(forest.size_category) # Dropping the month and day columns as they are not important forest = forest.drop(['month','day'],axis = 1) forest.head() forest.describe() forest.size_category.value_counts() forest.dtypes forest.shape # Splitting the data into x and y x = forest.drop(['size_category'],axis = 1) y = forest['size_category'] x y ###Output _____no_output_____ ###Markdown Building the model ###Code # Applying train and test split on the data from sklearn.model_selection import train_test_split x_train,x_test,y_train,y_test = train_test_split(x,y,test_size = 0.33, random_state = 0) svm = SVC(kernel = 'linear', gamma = 1, C = 1) svm.fit(x_train,y_train) preds = svm.predict(x_test) from sklearn.metrics import classification_report print(classification_report(preds,y_test)) from sklearn import metrics metrics.accuracy_score(y_test,preds)*100 ###Output _____no_output_____ ###Markdown Inference : Accuracy of the model is 98.83% ###Code metrics.precision_score(y_test,preds) metrics.f1_score(preds,y_test) from sklearn.metrics import confusion_matrix confusion_matrix(preds,y_test) ###Output _____no_output_____
notebooks/atn_db.ipynb
###Markdown Functions to create and import data to the database for atn_resilience ###Code #imports for the notebook import os # dir_path = os.path.dirname(os.getcwd()) dir_path = os.getcwd() script_dir = dir_path + '/atnresilience' os.chdir(script_dir) import create_atn_db #Create the paths for the database and raw files #dir_path is the path to the main directory db_path = '%s/data/processed/atn_db.sqlite' %(dir_path,) raw_path = '%s/data/raw/'%(dir_path,) processed_direc = '%s/data/processed/'%(dir_path,) print(db_path) print(processed_direc) ###Output /Users/allen/Documents/atnresilience/data/processed/atn_db.sqlite /Users/allen/Documents/atnresilience/data/processed/ ###Markdown Create the atn database from raw dataBefore running any of the following functions, create the following sub-directories in the main atnresilience directory:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /data/raw/ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /data/processed/ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /data/graph/In the '/data/raw/' directory, include all of the raw data files for the years to be processed.If a year has already been run, it does not need to be run again. DO NOT IMPORT THE SAME RAW DATA TWICE. THIS WILL CREATE A DUPLICATE IN THE DB. ###Code #Specify the range of years to add to the database: min_year = 2015 max_year = 2015 atn_db_loader = create_atn_db.ATNLoader() #Create the database and the table 'atn_performance' #If already exists, nothing will happen atn_db_loader.create_db() #Run the function to append the data from the specified years to the database. #Data for months 1-12 of that year but be in the folder '/data/raw' year_range = list(range(min_year, max_year+1)) for i in year_range: atn_db_loader.import_data(i) print('Data inserted to database for specified years') ###Output Finished inserting month 1 to DB. Finished inserting month 2 to DB. Finished inserting month 3 to DB. Finished inserting month 4 to DB. Finished inserting month 5 to DB. Finished inserting month 6 to DB. Finished inserting month 7 to DB. Finished inserting month 8 to DB. Finished inserting month 9 to DB. Finished inserting month 10 to DB. Finished inserting month 11 to DB. Finished inserting month 12 to DB. Finished inserting data for year 2015 Data inserted to database for specified years ###Markdown Create the airport coordinate database from raw dataBefore running any of the following functions, the airport coordinate data file must be added to the raw folder: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /data/raw/ The data can be downloaded from open flights: https://openflights.org/data.html . The extended dataset was used as the high-quality set does not include some airports which appear in the atn database. Header titles must first be added for at least the 'Country', 'ICAO', 'lat', and 'long' columns ###Code create_coord_db = create_atn_db.CoordinateLoader() create_coord_db.create_coords_table() create_coord_db.import_coords_data() ###Output _____no_output_____
1_Methods.ipynb
###Markdown Methods 1 - A model setup The main idea of the study is to estimate an upped bound of alkalinity generation in the Wadden Sea.The calculation of alkalinity changes is based on the concept of "explicitly conservative form of total alkalinity" ($\text{TA}_{\text{ec}}$) ([Wolf-Gladrow et al., 2007]):$\text{TA}_{\text{ec}} = \lbrack\text{Na}^{+}\rbrack + 2\lbrack\text{Mg}^{2 +}\rbrack + 2\lbrack\text{Ca}^{2 +}\rbrack + \lbrack \text{K}^{+}\rbrack + 2\lbrack\text{Sr}^{2 +}\rbrack + \text{TNH}_{3} - \lbrack\text{Cl}^{-}\rbrack - \lbrack\text{Br}^{-}\rbrack - \lbrack\text{NO}_{3}^{-}\rbrack - \text{TPO}_{4} - 2\text{TSO}_{4} - \text{THF} - \text{THNO}_{2}$, where$\text{TNH}_{3} = \lbrack\text{NH}_{3}\rbrack + \lbrack\text{NH}_{4}^{+}\rbrack$,$\text{TPO}_{4} = \lbrack\text{H}_{3}\text{PO}_{4}\rbrack + \lbrack \text{H}_{2}\text{PO}_{4}^{-}\rbrack + \lbrack\text{HPO}_{4}^{2 -}\rbrack + \lbrack\text{PO}_{4}^{3 -}\rbrack$,$\text{TSO}_{4} = \lbrack\text{SO}_{4}^{2 -}\rbrack + \lbrack\text{HSO}_{4}^{-}\rbrack$,$\text{THF} = \lbrack \text{F}^{-}\rbrack + \lbrack\text{HF}\rbrack$, and$\text{THNO}_{2} = \lbrack\text{NO}_{2}^{-}\rbrack + \lbrack\text{HNO}_{2}\rbrack$.[Wolf-Gladrow et al., 2007]: https://doi.org/10.1016/j.marchem.2007.01.006 Increase or decrease of concentrations of any of the $\text{TA}_{\text{ec}}$ compounds will change alkalinity.For example, an increase of concentration of $\lbrack\text{Ca}^{2 +}\rbrack$ by 1 mole will increase TA by 2 moles.Or an increase of concentration of $\lbrack\text{NO}_{3}^{-}\rbrack$ by 1 mole will decrease TA by 1 mole.These changes can be caused by biogeochemical reactions or other sources like freshwater fluxes, riverine inputs, fluxes to and from sediments (see for example [Zeebe and Wolf-Gladrow (2001)], [Follows et al. (2006)], [Wolf-Gladrow et al. (2007)]).[Zeebe and Wolf-Gladrow (2001)]: https://www.elsevier.com/books/co2-in-seawater-equilibrium-kinetics-isotopes/zeebe/978-0-444-50946-8[Follows et al. (2006)]: https://doi.org/10.1016/j.ocemod.2005.05.004[Wolf-Gladrow et al. (2007)]: https://doi.org/10.1016/j.marchem.2007.01.006 In order to estimate alkalinity generation in the Wadden Sea, we should consider all processes going on in the Wadden Sea that can change the concentrations of species in $\text{TA}_{\text{ec}}$.These processes are biogeochemical transformations listed in [Wolf-Gladrow et al. (2007)] and transport processes within and between water column and sediments of the Wadden Sea, advective exchange of the Wadden Sea with the surrounding areas.The reason that we have to include sediments along with the water column is the following.Some biogeochemical transformations in the coastal area, which can change TA, are active in the water column, others are more active and sediments.For example, typically denitrification takes place in the sediments, in the absence of oxygen ([Libes, 2011]).Primary production is often higher in the water column, where sunlight is more available ([Libes, 2011]).Therefore, we should consider both the water column and sediments.In this study, to calculate alkalinity, we consider both the water column and sediments of the Wadden Sea.We use a vertically resolved 1-D box as a proxy of the Wadden Sea, we split this box into different layers (to resolve a vertical resolution), calculate the necessary biogeochemical reactions increments for each layer, and evaluate the mixing between these layers.Also, we take into consideration the exchange of the water column of the 1-D box with an external pool (the Wadden Sea surrounding areas).[Wolf-Gladrow et al. (2007)]: https://doi.org/10.1016/j.marchem.2007.01.006[Libes, 2011]: https://www.elsevier.com/books/introduction-to-marine-biogeochemistry/libes/978-0-12-088530-5 A model setup for calculations consist of:1. The 1-D Sympagic-Pelagic-Benthic transport Model, SPBM ([Yakubov et al., 2019], https://github.com/BottomRedoxModel/SPBM). It is a governing program resolving a transport equation (diffusive and vertical advective (sinking, burying) terms) between and within the water column and sediments. SPBM also parametrizes horizontal exchange with the external pool (the Wadden Sea surrounding areas).2. A biogeochemical model (https://github.com/BottomRedoxModel/brom_niva_module/tree/dev-sham). It sends sources minus sinks terms to the transport model. The biogeochemical model is explained thoroughly in the Methods 2 section.The software is written in Fortran 2003.The SPBM and biogeochemical model are linked through the Framework for Aquatic Biogeochemical Models, FABM ([Bruggeman and Bolding, 2014]).[Yakubov et al., 2019]: https://doi.org/10.3390/w11081582[Bruggeman and Bolding, 2014]: https://doi.org/10.1016/j.envsoft.2014.04.002 The grid For calculations, to study alkalinity generation in the Wadden Sea we use the vertically resolved box (the modeling domain) containing the water column (the water domain) and sediments (the sediment domain).This vertically resolved box is a proxy of the Wadden Sea.Assuming a mean depth of the Wadden Sea of 2.5 m ([van Beusekom et al., 1999]), we split the water domain into two layers of 1.25 m and 1.15 m depth.Near the bottom, we have a benthic boundary layer (BBL) consisting of 2 layers of 0.05 m depth each.The BBL is a layer with eddy diffusion coefficients decreasing linearly to zero at the SWI.The sediment domain has 40 layers of 0.01 m depth each.[van Beusekom et al., 1999]: https://link.springer.com/article/10.1007/BF02764176 ![Image](misc/Grid.png "grid") **Figure M1-1**. The model grid scheme. Using the proposed grid the transport program (SPBM) updates each time step (300 sec.) the concentrations of the state variables (they are provided in the Methods 2 section) in each layer by contributions of diffusion, reaction (concentration increments from the biogeochemical model), advection, and horizontal exchange with the external pool. Forcing, initial and boundary conditions The functioning of the transport and biogeochemical models needs some forcing (for example, to calculate sources minus sinks terms the biogeochemical model requires data of seawater temperature, salinity, and photosynthetically active radiation (PAR)).Also, we have to establish state variables initial conditions and conditions on the boundaries of the modeling box.The data for forcing (seawater temperature, salinity, density) and initial conditions are averaged to one year from the World Ocean Database (WOD) for the years 2000 - 2010 from a rectangular region (the Southern North Sea, 54.35-55.37$^{\circ}$N 6.65-8.53$^{\circ}$E) that is adjacent to the North Frisian Wadden Sea.The data from WOD are stored in `wadden_sea.nc` file.The data of Chlorophyll a are taken from [Loebl et al. (2007)].The data of $\text{NH}_{4}^{+}$ are taken from [van Beusekom et al. (2009)].Boundary conditions are set up for $\text{O}_{2}$ at the surface boundary as an exchange with the atmosphere as in ([Yakushev et al., 2017]).For all other species, boundary conditions at the bottom and the surface interfaces of the model box are set to zero fluxes.[Loebl et al. (2007)]: https://doi.org/10.1016/j.seares.2007.06.003[van Beusekom et al. (2009)]: https://doi.org/10.1016/j.seares.2008.06.005[Yakushev et al., 2017]: https://doi.org/10.5194/gmd-10-453-2017 For diffusive updates, SPBM needs to know the vertical diffusion coefficients in the water column and the dispersion coefficients in sediments (which are analogs to vertical diffusion coefficients in the water column).The vertical diffusion coefficients in the water column are calculated according to the vertical density distributions following [Gargett (1984)].Vertical advective updates in the water column (sinking of the particles) are calculated according to the sinking velocities of particles.The dispersion coefficients in sediments and sinking velocities of particles are discussed in the Methods 3 section.Vertical advective updates in the sediments (burying) are neglected (no burying).[Gargett (1984)]: https://doi.org/10.1357/002224084788502756 SPBM calculates some state variables' horizontal exchange of the modeling domain with the external pool.To supply the model water domain with nutrients for the proper functioning of the phytoplankton model, we introduce horizontal exchange of concentration of phosphates, ammonium, nitrates, and silicates in the modeling domain with concentrations in the external pool.The concentrations of variables in the external pool are considered to have a permanent seasonal profile.The seasonal profiles of phosphates, nitrate, and silicates external pool concentrations are from the World Ocean Database from the same region as the data for forcing.Ammonium external pool seasonal profile concentrations are from [van Beusekom et al. (2009)].Horizontal exchange is controlled by the horizontal diffusivity coefficient$\ K_{h}$ ([Okubo, 1971], [Okubo, 1976]).The value of the horizontal diffusivity coefficient is discussed in the Methods 3 section.Along with concentrations of the corresponding elements, phosphate, ammonium and nitrate exchange also affects alkalinity according to $\text{TA}_{\text{ec}}$ expression.Sulfate ion ($\text{SO}_{4}^{2 -}$) is a compound of $\text{TA}_{\text{ec}}$ so it is also taken into account by horizontal exchange for the alkalinity exchange evaluation between the model water domain and the external pool.$\text{SO}_{4}^{2 -}$ affects TA according to $\text{TA}_{\text{ec}}$ expression as well.It is a major ion so its concentration in the external pool is approximated by a constant value of 25000 $\text{mM m}^{- 3}$.The advective exchange of other state variables is not considered (concentrations of these state variables in the external pool are assumed to be similar to the concentrations in the modeling domain).[van Beusekom et al. (2009)]: https://doi.org/10.1016/j.seares.2008.06.005[Okubo, 1971]: https://doi.org/10.1016/0011-7471(71)90046-5[Okubo, 1976]: https://doi.org/10.1016/0011-7471(76)90897-4 SPBM calculates the allochtonous organic matter influx to the modeling domain.To reflect the heterotrophic nature of the Wadden Sea ([van Beusekom et al., 1999]) we add an additional advective influx of particulate OM state variable ($\text{POM}$).This $\text{POM}$ inflow is adopted from the value for the net import of OM to the Sylt-Rømø basin in the North Frisian Wadden Sea (110 $\text{g}\ \text{m}^{- 2}\ \text{year}^{- 1}$) reported in ([van Beusekom et al., 1999]) as a sinusoidal curve with a maximum in May ([Joint and Pomroy, 1993]; [de Beer et al., 2005]).This value is also close to the Wadden Sea average OM input (100 $\text{g}\ \text{m}^{- 2}\ \text{year}^{- 1}$) from the North Sea ([van Beusekom et al., 1999]).[van Beusekom et al., 1999]: https://doi.org/10.1007/BF02764176[Joint and Pomroy, 1993]: https://www.int-res.com/articles/meps/99/m099p169.pdf[de Beer et al., 2005]: https://doi.org/10.4319/lo.2005.50.1.0113 IPython notebook `s_1_generate_netcdf.ipynb` reads the data from WOD (`wadden_sea.nc`) and forms another NetCDF data file `wadden_sea_out.nc` which contains the data filtered and averaged to one year, calculated diffusion coefficients, calculated theoretical surface PAR values for the region of the Wadden Sea, and calculated OM influx.The governing program SPBM uses `wadden_sea_out.nc` to get all the necessary information.There is an IPython notebook to check the data written in `wadden_sea_out.nc` - `s_2_check_data.ipynb` Preliminary evaluations for the biogeochemical model construction We have a tool to calculate the transport of the state variables in the multilayer box representing the Wadden Sea, but we still missing the biogeochemical model to update the concentrations of the state variables due to biogeochemical reactions.Here we provide the reasoning to include some reactions and skip others.There are thirteen terms in $\text{TA}_{\text{ec}}$ expression and the most abundant biogeochemical processes in the coastal ocean change the concentrations of six of them:$2\lbrack\text{Ca}^{2 +}\rbrack$, $\text{TNH}_{3}$, $\lbrack\text{NO}_{3}^{-}\rbrack$, $\text{TPO}_{4}$, $2\text{TSO}_{4}$, $\text{THNO}_{2}$.Therefore, if the biogeochemical reactions change the concentration of certain terms, they also change TA.The influence of the biogeochemical reactions on alkalinity directly follows from $\text{TA}_{\text{ec}}$ expression ([Wolf-Gladrow et al., 2007], see also the definition of $\text{TA}_{\text{ec}}$ in the beginning of this Section):[Wolf-Gladrow et al., 2007]: https://doi.org/10.1016/j.marchem.2007.01.006 1. Nutrient assimilation by primary producers. * Assimilation of one mole of $\text{NO}_{3}^{-}$ or $\text{NO}_{2}^{-}$ increases alkalinity by one mole, assimilation of one mole of $\text{NH}_{4}^{+}$ decrease alkalinity by one mole. * Assimilation of one mole of phosphate increases alkalinity by one mole.2. Organic matter degradation. * Oxygen respiration increases alkalinity by 15 moles ($16\text{NH}_{3} - 1\text{H}_{3}\text{PO}_{4}$) per 106 moles of $\text{CH}_{2}\text{O}$ oxidized:$(\text{CH}_{2}\text{O})_{106}(\text{NH}_{3})_{16}\text{H}_{3}\text{PO}_{4} + 106\text{O}_{2} \rightarrow 106\text{CO}_{2} + 16\text{NH}_{3} + \text{H}_{3}\text{PO}_{4} + 106\text{H}_{2}\text{O}$. * Denitrification increases alkalinity by 99.8 moles ($84.8\text{HNO}_{3} + 16\text{NH}_{3} - 1\text{H}_{3}\text{PO}_{4}$) per 106 moles of $\text{CH}_{2}\text{O}$ oxidized:$(\text{CH}_{2}\text{O})_{106}(\text{NH}_{3})_{16}\text{H}_{3}\text{PO}_{4} + 84.8\text{HNO}_{3} \rightarrow 106\text{CO}_{2} + 42.4\text{N}_{2} + 16\text{NH}_{3} + \text{H}_{3}\text{PO}_{4} + 148.4\text{H}_{2}\text{O}$. * Sulfate reduction increases alkalinity by 121 moles ($2 \cdot 53\text{SO}_{4}^{2 -} + 16\text{NH}_{3} - 1\text{H}_{3}\text{PO}_{4}$) per 106 moles of $\text{CH}_{2}\text{O}$ oxidized:$(\text{CH}_{2}\text{O})_{106}(\text{NH}_{3})_{16}\text{H}_{3}\text{PO}_{4} + 53\text{SO}_{4}^{2-} \rightarrow 106\text{HCO}_{3}^{-} + 16\text{NH}_{3} + \text{H}_{3}\text{PO}_{4} + 53\text{H}_{2}\text{S}$. * Other OM degradation reactions.3. Nitrification, which decreases alkalinity by two moles per mole of $\text{NH}_{4}^{+}$ oxidized:$\text{NH}_{4}^{+} + 1.5\text{O}_{2} \rightarrow \text{NO}_{3}^{-} + 2\text{H}^{+} + \text{H}_{2}\text{O}$. 4. Calcium carbonate precipitation and dissolution. * Precipitation of one mole of calcium carbonate decreases alkalinity by two moles:$\text{Ca}^{2+} + 2\text{HCO}_{3}^{-} \rightarrow \text{CaCO}_{3} + \text{CO}_{2} + \text{H}_{2}\text{O}$or$\text{Ca}^{2+} + \text{CO}_{3}^{-} \rightarrow \text{CaCO}_{3}$. * Calcium carbonate dissolution increases alkalinity by two moles per one mole of calcium carbonate dissolved:$\text{CaCO}_{3} + \text{CO}_{2} + \text{H}_{2}\text{O} \rightarrow \text{Ca}^{2 +} + 2\text{HCO}_{3}^{-}$. Now we can try to estimate which of these processes are the most important ones for alkalinity changes in the Wadden Sea.At first, we write down the mean concentrations of alkalinity and the mentioned six compounds ($\lbrack\text{Ca}^{2 +}\rbrack$, $\text{TNH}_{3}$, $\lbrack\text{NO}_{3}^{-}\rbrack$, $\text{TPO}_{4}$, $\text{TSO}_{4}$, $\text{THNO}_{2}$, all concentration are in $\text{mM m}^{- 3}$) in the Southern Wadden Sea.We use these mean concentrations from the Southern Wadden Sea as initial state of concentrations in the Wadden Sea before local biogeochemical transformations.So we can see the concentrations of $\text{TA}_{\text{ec}}$ compounds that correspond to $\text{TA}_{\text{ec}}$, afterwards we can track how biogeochemical transformations change alkalinity. ###Code import src.fetch_data as fd import numpy as np import matplotlib.pyplot as plt import seaborn as sns sns.set() # get some data from the World Ocean Database (WOD) par, temperature, no3, ammonium, po4, si, irradiance = fd.get_data() f'NH4={ammonium.mean()}; NO3={no3.mean()}; PO4={po4.mean()}' ###Output _____no_output_____ ###Markdown Nitrites' concentration is negligibly small, so we skip it.Also, we assume that average TA concentration equals 2300 $\text{mM m}^{- 3}$.$\text{Ca}^{2 +}$ and $\text{TSO}_{4}$ are the major ions of seawater with the following approximate concentrations (in $\text{mM m}^{- 3}$): ###Code Ca, SO4 = (10000, 25000) ###Output _____no_output_____ ###Markdown Initial concentrations of TA compound elements before local biogeochemical transformations:|Parameter:|$$\lbrack\text{Ca}^{2+}\rbrack$$|$$\text{TNH}_{3}$$|$$\lbrack\text{NO}_{3}^{-}\rbrack$$|$$\text{TPO}_{4}$$|$$\text{TSO}_{4}$$|$$\text{THNO}_{2}$$|$$\text{TA}$$||:-|:-:|:-:|:-:|:-:|:-:|:-:|:-:||Values, $\text{mM m}^{- 3}$:|10000|3.4|16.1|0.6|25000|0|2300| These values correspond to each other, for example, $\text{NO}_{3}^{-}$ concentration of 16 $\text{mM m}^{- 3}$ corresponds to TA of 2300 $\text{mM m}^{- 3}$.An increase of $\text{NO}_{3}^{-}$ by one mole will decrease TA by one mole (due to negative charge sign).Thus, we can track TA changes due to changes of its compound ions.To understand how biogeochemical reactions can affect TA we make a function calculating TA changes according to $\text{TA}_{\text{ec}}$ expression:$$\delta [\text{TA}] = 2\delta [\text{Ca}^{2 +}] - 2\delta [\text{TSO}_{4}] + \delta [\text{NH}_{4}^{+}] - \delta [\text{NO}_{3}^{-}] - \delta [\text{PO}_{4}^{-}]$$For example, if $\text{NO}_{3}^{-}$ drops down to zero (from 16), it will increase alkalinity by 16 $\text{mM m}^{- 3}$.Providing a change of a particular compound we can track a TA change. ###Code def alk_change(TA, dCa=0, dSO4=0, dNH4=0, dNO3=0, dPO4=0): return TA + 2*dCa - 2*dSO4 + dNH4 - dNO3 - dPO4 def sinusoidal(max_value): """Creates a sinusoidal line with a period of 365, minimum value of zero, and a maximum value of max_value""" day=np.arange(0,365,1) return (1/2)*max_value*(1+np.sin(2*np.pi*((day-90)/365))) ###Output _____no_output_____ ###Markdown Let's test a TA change due to a change of $\text{Ca}^{2 +}$ concentration.For example, calcifiers consume 100 $\text{mM m}^{- 3}$ of $\text{Ca}^{2 +}$ during a year, and then the equal amount of calcifiers' skeletons dissolve restoring the concentration of $\text{Ca}^{2 +}$ in the end of the year. ###Code dCa = -sinusoidal(100) Ca_year = Ca + dCa TA_year = alk_change(TA = 2300, dCa = dCa) ox = np.arange(0,365,1) fig = plt.figure(figsize=(8, 6)) ax = fig.add_subplot(2, 1, 1) # row-col-num ax1 = fig.add_subplot(2, 1, 2) ax.plot(ox, Ca_year); ax1.plot(ox, TA_year) ax.set_ylabel('Ca$^{2+}$'); ax1.set_ylabel('TA'); ax1.set_xlabel('day') ###Output _____no_output_____ ###Markdown **Figure M1-2**. TA response to $\text{Ca}^{2 +}$ change. We see that consuming of 100 $\text{mM m}^{- 3}$ of $\text{Ca}^{2 +}$ decreases alkalinity by 200 $\text{mM m}^{- 3}$, which is obvious from $\text{TA}_{\text{ec}}$ expression.The local activities of calcifiers cannot increase alkalinity above 2300 $\text{mM m}^{- 3}$.To increase TA we need an input of $\text{Ca}^{2 +}$, which can come in form of $\text{Ca}^{2 +}$ or $\text{CaCO}_3$.Additional $\text{Ca}^{2 +}$ can come with terrestrial inflow.We do not consider it here since we are interested in biogeochemical transformation occurring in the Wadden Sea.The supply of allochtonous $\text{CaCO}_3$ to the Wadden Sea has not yet been reported ([Thomas et al., 2009]).Calcium carbonate related biogeochemical processes cannot increase alkalinity in the Wadden Sea.As a first approximation according to the goal to calculate the maximum alkalinity generation in the Wadden Sea due to biogeochemical processes we can skip $\text{CaCO}_3$ precipitation/dissolution while preparing the biogeochemical model.[Thomas et al., 2009]: https://doi.org/10.5194/bg-6-267-2009 Now let's assume that sulfate reduction decreases $\text{SO}_{4}^{2 -}$ by 100 $\text{mM m}^{- 3}$. ###Code dSO4 = -sinusoidal(100) SO4_year = SO4 + dSO4 TA_year = alk_change(TA = 2300, dSO4 = dSO4) fig = plt.figure(figsize=(8, 6)) ax, ax1 = (fig.add_subplot(2, 1, 1), fig.add_subplot(2, 1, 2)) ax.plot(ox, SO4_year); ax1.plot(ox, TA_year) ax.set_ylabel('SO$_4^{2-}$'); ax1.set_ylabel('TA') ax1.set_xlabel('day') ###Output _____no_output_____
part_0/python_grammar_00.ipynb
###Markdown Python特点 Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言。* 编程语言目的:编程语言是用来写程序,目的是让计算机来执行程序;CPU只识别机器指令,因此不同的编程语言都需要"翻译"成机器指令;但是不同的编程语言写同一个任务所需要的代码量不同。比如,C语言1000行代码,Java只要100行,而Python可能只要20行,所以Python是一种相当高级的语言;代码少的代价是运行速度慢其他流行的编程语言特点:* C语言:面向过程语言,速度快,适合编写操作系统和嵌入式程序* Java:面向对象语法简洁,适合网页App * JavaScript:网页编程**每种编程语言都有各自的特性,因此没有最好的语言只有最合适某种情况的语言**使用Python开发的APP和其他应用:* Youtube - 视频社交网站* 豆瓣网 - 电影等文化产品的资料数据库网站* 知乎 - 一个问答网站* 人工智能程序框架 - TensorFlowPython优点: 1-语法简单,拥有大量的三方库 2-AI开发的“官方”语言Python缺点:1-运行速度慢;因为Python是解释型语言,你的代码在执行时会一行一行地翻译成CPU能理解的机器码,这个翻译过程非常耗时;而C程序是运行前直接编译成CPU能执行的机器码,所有速度快2-代码不能加密。如果要发布你的Python程序,实际上就是发布源代码,这一点跟C语言不同,C语言不用发布源代码,只需要把编译后的机器码(也就是你在Windows上常见的xxx.exe文件)发布出去 Python解释器 Python有多种不同的解释器1-CPython:Python官方网站下载并安装好Python 3.x后,就得到一个官方版本的解释器:CPython。这个解释器是用C语言开发的,所以叫CPython(使用最广泛的解释器)2-IPython:基于CPython之上的一个交互式解释器,IPython只是在交互方式上有所增强,但是执行Python代码的功能和CPython是完全一样的3-Jython:运行在Java平台上的Python解释器,可以直接把Python代码编译成Java字节码执行 运行Python文件 有同学问,能不能像.exe文件那样直接运行.py文件呢?在Windows上是不行的,但是在Mac和Linux上是可以的,方法是在.py文件的第一行加上一个特殊的注释:!/usr/bin/env python3 print('hello, world')然后,通过命令给hello.py以执行权限:$ chmod a+x hello.pybash hello.py注:现在基本都是通过安装Anaconda来创建所需的Python环境,同时Python的第三方包的安装和管理也十分方便。 编程语言流行榜-TIOBE排行榜(2020年) ###Code %%html <img src='TIOBE排行榜.png', width=800, height=500> ###Output _____no_output_____
lipschitz_estimates/ionoshpere_lipschitz_estimates.ipynb
###Markdown Ionoshpere Dataset - Lipschitz Continuity - LIME - SHAP ###Code print("Bismillahir Rahmanir Rahim") ###Output Bismillahir Rahmanir Rahim ###Markdown Imports and Paths ###Code from IPython.display import display, HTML from lime.lime_tabular import LimeTabularExplainer from pprint import pprint from scipy.spatial.distance import pdist, squareform from sklearn.linear_model import LogisticRegression from sklearn.tree import DecisionTreeClassifier, export_graphviz from sklearn.ensemble import RandomForestClassifier from sklearn.pipeline import make_pipeline from sklearn.preprocessing import StandardScaler, MinMaxScaler from sklearn.model_selection import train_test_split from sklearn.metrics import f1_score, confusion_matrix from sklearn.utils.multiclass import unique_labels from sklearn import metrics from sklearn.metrics import classification_report from sklearn.metrics.pairwise import cosine_similarity from scipy import spatial %matplotlib inline import glob import matplotlib.pyplot as plt import numpy as np import pandas as pd import pathlib import sklearn import seaborn as sns import statsmodels import eli5 import lime import shap shap.initjs() ###Output _____no_output_____ ###Markdown Load and preprocess dataTrain/test split = 0.80/0.20 ###Code # Set the seed experimentations and interpretations. np.random.seed(111) project_path = pathlib.Path.cwd().parent.parent import pathlib dataset_path = str(project_path) + '/datasets/ionosphere/ionosphere.data' # print(dataset_path) fp = open(dataset_path, "r") rows = [] for line in fp: rows.append(line) rows_sep = [sub.split(",") for sub in rows] iono = pd.DataFrame(np.array(rows_sep)) iono_col_names = np.array(iono.columns.tolist()).astype(str) iono_col_names = np.where(iono_col_names=='34', 'label', iono_col_names) iono.columns = iono_col_names iono['label'] = iono['label'].apply(lambda label: label.split('\n')[0]) labels_iono = iono['label'] labels_iono_list = labels_iono.values.tolist() # labels_iono_codes = labels_train_iono.astype("category").cat.codes features_iono = iono.iloc[:,:-1] display(iono.head()) train_iono, test_iono, labels_train_iono, labels_test_iono = train_test_split( features_iono, labels_iono, train_size=0.80) labels_train_iono_codes = labels_train_iono.astype("category").cat.codes labels_test_iono_codes = labels_test_iono.astype("category").cat.codes """ This form is only compatiable with rest of the notebook code. """ train = train_iono.to_numpy().astype(float) labels_train = labels_train_iono.to_numpy() test = test_iono.to_numpy().astype(float) labels_test = labels_test_iono.to_numpy() x_testset = test feature_names = features_iono.columns.values target_names = np.unique(labels_test) # here 0 = 'b' & 1 = 'g' unique_targets = np.unique([0, 1]) # LIME only takes integer, print("Feature names", feature_names) print("Target names", target_names) print("Number of uniques label or target names", unique_targets) print("Training record", train[0:1]) print("Label for training record", labels_train[0:1]) ###Output Training record [[ 1. 0. 0.52542 -0.0339 0.94915 0.08475 0.52542 -0.16949 0.30508 -0.01695 0.50847 -0.13559 0.64407 0.28814 0.83051 -0.35593 0.54237 0.01695 0.55932 0.0339 0.59322 0.30508 0.86441 0.05085 0.40678 0.15254 0.67287 -0.00266 0.66102 -0.0339 0.83051 -0.15254 0.76271 -0.10169]] Label for training record ['g'] ###Markdown Train and evaluate models.Train Logistic Regression and Random Forest models so these can be used as black box models when evaluating explanations methods. Fit Logistic Regression and Random Forest ###Code lr = sklearn.linear_model.LogisticRegression(class_weight='balanced') lr.fit(train, labels_train) rf = RandomForestClassifier(n_estimators=500, class_weight='balanced_subsample') rf.fit(train, labels_train) ###Output _____no_output_____ ###Markdown Predict using logistic regression and random forest models ###Code labels_pred_lr = lr.predict(test) labels_pred_rf = rf.predict(test) score_lr = metrics.accuracy_score(labels_test, labels_pred_lr) score_rf = metrics.accuracy_score(labels_test, labels_pred_rf) print("Logitic Regression accuracy score.", score_lr) predict_proba_lr = lr.predict_proba(test[:5]) print("\nLogistic Regression predict probabilities\n\n", predict_proba_lr) predict_lr = lr.predict(test[:5]) print("\nLogistic Regression predictions", predict_lr) print("\n\n\nRandom Forest accuracy score.", score_rf) predict_proba_rf = rf.predict_proba(test[:5]) print("\nRandom Forest predict probabilities\n\n", predict_proba_rf) predict_rf = rf.predict(test[:5]) print("\nRandom Forest predictions", predict_rf) ###Output Logitic Regression accuracy score. 0.8309859154929577 Logistic Regression predict probabilities [[0.98942588 0.01057412] [0.35666392 0.64333608] [0.01094379 0.98905621] [0.90375436 0.09624564] [0.1104594 0.8895406 ]] Logistic Regression predictions ['b' 'g' 'g' 'b' 'g'] Random Forest accuracy score. 0.9577464788732394 Random Forest predict probabilities [[0.984 0.016] [0.08 0.92 ] [0.756 0.244] [0.904 0.096] [0.048 0.952]] Random Forest predictions ['b' 'g' 'b' 'b' 'g'] ###Markdown Classification reports of logistic regression and random forest ###Code report_lr = classification_report(labels_test, labels_pred_lr, target_names=target_names) print("Logistic Regression classification report.") print(report_lr) report_rf = classification_report(labels_test, labels_pred_rf, target_names=target_names) print("Random Forestclassification report.") print(report_rf) ###Output Logistic Regression classification report. precision recall f1-score support b 0.82 0.69 0.75 26 g 0.84 0.91 0.87 45 accuracy 0.83 71 macro avg 0.83 0.80 0.81 71 weighted avg 0.83 0.83 0.83 71 Random Forestclassification report. precision recall f1-score support b 0.93 0.96 0.94 26 g 0.98 0.96 0.97 45 accuracy 0.96 71 macro avg 0.95 0.96 0.95 71 weighted avg 0.96 0.96 0.96 71 ###Markdown Classification reports display as dataframes ###Code total_targets = len(target_names) report_lr = classification_report(labels_test, labels_pred_lr, target_names=target_names, output_dict=True) report_lr = pd.DataFrame(report_lr).transpose().round(2) report_lr = report_lr.iloc[:total_targets,:-1] display(report_lr) report_rf = classification_report(labels_test, labels_pred_rf, target_names=target_names, output_dict=True) report_rf = pd.DataFrame(report_rf).transpose().round(2) report_rf = report_rf.iloc[:total_targets,:-1] display(report_rf) avg_f1_lr = report_lr['f1-score'].mean() print("Logistic Regression average f1-score", avg_f1_lr) avg_f1_rf = report_rf['f1-score'].mean() print("Random Forest average f1-score", avg_f1_rf) ###Output Logistic Regression average f1-score 0.81 Random Forest average f1-score 0.955 ###Markdown Confusion matrix of logistic regression and random forest ###Code matrix_lr = confusion_matrix(labels_test, labels_pred_lr) matrix_lr = pd.DataFrame(matrix_lr, columns=target_names).transpose() matrix_lr.columns = target_names display(matrix_lr) matrix_rf = confusion_matrix(labels_test, labels_pred_rf) matrix_rf = pd.DataFrame(matrix_rf, columns=target_names).transpose() matrix_rf.columns = target_names display(matrix_rf) ###Output _____no_output_____ ###Markdown Combine confusion matrix and classification report of logistic regression and random forest ###Code matrix_report_lr = pd.concat([matrix_lr, report_lr], axis=1) display(matrix_report_lr) matrix_report_rf = pd.concat([matrix_rf, report_rf], axis=1) display(matrix_report_rf) ###Output _____no_output_____ ###Markdown Saving matrices and reports into csvThese CSVs can be used easily to draw tables in LaTex. ###Code file_path = str(project_path) + '/datasets/modelling-results/' filename = 'iono_matrix_report_lr.csv' matrix_report_lr.to_csv(file_path + filename, index=True) filename = 'iono_matrix_report_rf.csv' matrix_report_rf.to_csv(file_path + filename, index=True) ###Output _____no_output_____ ###Markdown Extract predicted target names for logistic regression and random forest ###Code target_names = target_names targets = unique_targets targets_labels = dict(zip(targets, target_names)) print(targets_labels) ###Output {0: 'b', 1: 'g'} ###Markdown Ionoshpere dataset specific changes to extract codesExtracting code such as [0, 1] against ['b', 'g'] values ###Code dummies = pd.get_dummies(labels_pred_lr) labels_pred_codes_lr = dummies.values.argmax(1) dummies = pd.get_dummies(labels_pred_rf) labels_pred_codes_rf = dummies.values.argmax(1) labels_names_pred_lr = [] for label in labels_pred_codes_lr: labels_names_pred_lr.append(targets_labels[label]) labels_names_pred_rf = [] for label in labels_pred_codes_rf: labels_names_pred_rf.append(targets_labels[label]) print("Logistic Regression predicted targets and their names.\n") print(labels_pred_codes_lr) print(labels_names_pred_lr) print("\n\nRandom Forest predicted targets and their names.") print(labels_pred_codes_rf) print(labels_names_pred_rf) ###Output Logistic Regression predicted targets and their names. [0 1 1 0 1 1 1 1 1 0 0 1 0 1 1 1 0 1 0 1 1 0 1 0 1 1 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 0 0 1 1 1 1 0 0 0 1] ['b', 'g', 'g', 'b', 'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g', 'b', 'g', 'g', 'g', 'b', 'g', 'b', 'g', 'g', 'b', 'g', 'b', 'g', 'g', 'g', 'b', 'g', 'g', 'g', 'g', 'b', 'b', 'g', 'g', 'b', 'g', 'g', 'g', 'b', 'g', 'g', 'g', 'g', 'b', 'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g', 'g', 'b', 'b', 'g', 'g', 'g', 'g', 'b', 'b', 'b', 'g'] Random Forest predicted targets and their names. [0 1 0 0 1 1 1 1 1 0 0 1 0 1 1 0 0 1 0 1 1 1 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 1 1 0 1 1 1 0 0 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 0 0 1 0 0] ['b', 'g', 'b', 'b', 'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g', 'b', 'g', 'g', 'b', 'b', 'g', 'b', 'g', 'g', 'g', 'g', 'b', 'g', 'g', 'g', 'b', 'g', 'b', 'g', 'g', 'b', 'b', 'g', 'b', 'b', 'g', 'g', 'g', 'b', 'g', 'g', 'g', 'b', 'b', 'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g', 'g', 'g', 'b', 'b', 'g', 'b', 'b'] ###Markdown Interpret Black Box Models 1. Interpret Logitistic Regression and Random Forest using LIME LIME explanations util functions ###Code def lime_explanations(index, x_testset, explainer, model, unique_targets, class_predictions): instance = x_testset[index] exp = explainer.explain_instance(instance, model.predict_proba, labels=unique_targets, top_labels=None, num_features=len(x_testset[index]), num_samples=6000) # Array class_predictions contains predicted class labels exp_vector_predicted_class = exp.as_map()[class_predictions[index]] return (exp_vector_predicted_class, exp.score), exp def explanation_to_dataframe(index, x_testset, explainer, model, unique_targets, class_predictions, dataframe): feature_imp_tuple, exp = lime_explanations(index, x_testset, explainer, model, unique_targets, class_predictions) exp_val = tuple(sorted(feature_imp_tuple[0])) data = dict((x, y) for x, y in exp_val) list_val = list(data.values()) list_val.append(feature_imp_tuple[1]) dataframe.loc[index] = list_val return dataframe, exp """ Define LIME Explainer """ explainer_lime = LimeTabularExplainer(train, mode = 'classification', training_labels = labels_train, feature_names=feature_names, verbose=False, class_names=target_names, feature_selection='auto', discretize_continuous=True) from tqdm import tqdm col_names = list(feature_names) col_names.append('lime_score') ###Output _____no_output_____ ###Markdown Interpret logistic regression on testset using LIME ###Code explanations_lime_lr = pd.DataFrame(columns=col_names) for index in tqdm(range(0,len(test))): explanations_lime_lr, exp = explanation_to_dataframe(index, test, explainer_lime, rf, # random forest model unique_targets, labels_pred_codes_lr, # random forest predictions explanations_lime_lr) print("LIME explanations on logistic regression.") display(explanations_lime_lr.head()) display(explanations_lime_lr.iloc[:,:-1].head(1)) ###Output LIME explanations on logistic regression. ###Markdown Interpret random forest on testset using LIME ###Code explanations_lime_rf = pd.DataFrame(columns=col_names) for index in tqdm(range(0,len(test))): explanations_lime_rf, exp = explanation_to_dataframe(index, test, explainer_lime, rf, # random forest model unique_targets, labels_pred_codes_rf, # random forest predictions explanations_lime_rf) print("LIME explanations on random forest.") display(explanations_lime_rf.head()) display(explanations_lime_rf.iloc[:,:-1].head(1)) ###Output LIME explanations on random forest. ###Markdown 2. Interpret Logitistic Regression and Random Forest using SHAP ###Code def shapvalue_to_dataframe(test, labels_pred, shap_values, feature_names): exp_shap_array = [] for test_index in range(0, len(test)): label_pred = labels_pred[test_index] exp_shap_array.append(shap_values[label_pred][test_index]) df_exp_shap = pd.DataFrame(exp_shap_array) df_exp_shap.columns = feature_names return df_exp_shap ###Output _____no_output_____ ###Markdown Interpret logistic regression using SHAP ###Code shap_train_summary = shap.kmeans(train, 50) explainer_shap_lr = shap.KernelExplainer(lr.predict_proba, shap_train_summary) # print("Shap Train Sample Summary", shap_train_summary) shap_values_lr = explainer_shap_lr.shap_values(test, nsamples='auto') shap_expected_values_lr = explainer_shap_lr.expected_value print("Shapley Expected Values", shap_expected_values_lr) shap.summary_plot(shap_values_lr, test, feature_names=feature_names) ###Output _____no_output_____ ###Markdown Interpret random forest using SHAP ###Code shap_values_rf = shap.TreeExplainer(rf).shap_values(test) shap.summary_plot(shap_values_rf, test, feature_names=feature_names) ###Output _____no_output_____ ###Markdown Extract explanations from SHAP values computed on logistic regressions and random forest models. Preprocessing SHAP values**_shap_values_** returns 3D array in a form of (num_classes, num_test_instance, num_features) e.g. in our iris dataset it will be (3, 30, 4) ###Code explanations_shap_lr = shapvalue_to_dataframe(test, labels_pred_codes_lr, shap_values_lr, feature_names) display(explanations_shap_lr.head()) display(explanations_shap_lr.iloc[:,:].head(1)) explanations_shap_rf = shapvalue_to_dataframe(test, labels_pred_codes_rf, shap_values_rf, feature_names) display(explanations_shap_rf.head()) display(explanations_shap_rf.iloc[:,:].head(1)) ###Output _____no_output_____ ###Markdown Local Lipschitz Estimates as a stability measure for LIME & SHAP Find Local Lipschitz of points L(x) Define neighborhood around anchor point x0 ###Code def norm(Xs, x0, norm=2): # https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.norm.html norm = np.linalg.norm(x0 - Xs, norm) # /np.linalg.norm(b[0] - b, 2) return norm def neighborhood_with_euclidean(x_points, anchor_index, radius): x_i = x_points[anchor_index] radius = radius * np.sqrt(len(x_points[anchor_index])) x_js = x_points.tolist() del x_js[anchor_index] dist = (x_i - x_js)**2 dist = np.sum(dist, axis=1) dist = np.sqrt(dist) neighborhood_indices = [] for index in range(0, len(dist)): if dist[index] < radius: neighborhood_indices.append(index) return neighborhood_indices def neighborhood_with_KDTree(x_points, anchor_index, radius): # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.KDTree.query_ball_point.html tree = spatial.KDTree(x_points) neighborhood_indices = tree.query_ball_point(x_points[anchor_index], radius * np.sqrt(len(x_points[anchor_index]))) return neighborhood_indices ###Output _____no_output_____ ###Markdown Local Lipschitz of explanation methods (LIME, SHAP) ###Code def lipschitz_formula(nearby_points, nearby_points_exp, anchorX, anchorX_exp): anchorX_norm2 = np.apply_along_axis(norm, 1, nearby_points, anchorX) anchorX_exp_norm2 = np.apply_along_axis(norm, 1, nearby_points_exp, anchorX_exp) anchorX_avg_norm2 = anchorX_exp_norm2/anchorX_norm2 anchorX_LC_argmax = np.argmax(anchorX_avg_norm2) return anchorX_avg_norm2, anchorX_LC_argmax def lipschitz_estimate(anchorX, x_points, explanations_x_points, anchor_index, neighborhood_indices): # extract anchor point explanations anchorX_exp = explanations_x_points[anchor_index] # extract anchor point neighborhood's explanations nearby_points = x_points[neighborhood_indices] nearby_points_exp = explanations_x_points[neighborhood_indices] # find local lipschitz estimate (lc) anchorX_avg_norm2, anchorX_LC_argmax = lipschitz_formula(nearby_points, nearby_points_exp, anchorX, anchorX_exp) return anchorX_avg_norm2, anchorX_LC_argmax def find_lipschitz_estimates(x_points, x_points_lime_exp, x_points_shap_exp, radii): # https://docs.scipy.org/doc/numpy/reference/generated/numpy.apply_along_axis.html # https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.argmax.html # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.KDTree.query_ball_point.html instances = [] anchor_x_index = [] lc_coefficient_lime = [] x_deviation_index_lime = [] x_deviation_index_shap = [] lc_coefficient_shap = [] radiuses = [] neighborhood_size = [] for radius in radii: for anchor_index in range(0, len(x_points)): # define neighorbood of around anchor point using radius # neighborhood_indices = neighborhood_with_KDTree(x_points, anchor_index, radius) # neighborhood_indices.remove(anchor_index) # remove anchor index to remove anchor point neighborhood_indices = neighborhood_with_euclidean(x_points, anchor_index, radius) print(neighborhood_indices) radiuses.append(radius) if len(neighborhood_indices) == 0: continue neighborhood_size.append(len(neighborhood_indices)) # extract anchor point and its original index anchorX = x_points[anchor_index] instances.append(anchorX) anchor_x_index.append(anchor_index) # find local lipschitz estimate (lc) LIME anchorX_avg_norm2, anchorX_LC_argmax = lipschitz_estimate(anchorX, x_points, x_points_lime_exp, anchor_index, neighborhood_indices) lc_coefficient_lime.append(anchorX_avg_norm2[anchorX_LC_argmax]) # find deviation point from anchor point LIME explanations deviation_point_index = neighborhood_indices[anchorX_LC_argmax] x_deviation_index_lime.append(deviation_point_index) # find local lipschitz estimate (lc) SHAP anchorX_avg_norm2, anchorX_LC_argmax = lipschitz_estimate(anchorX, x_points, x_points_shap_exp, anchor_index, neighborhood_indices) lc_coefficient_shap.append(anchorX_avg_norm2[anchorX_LC_argmax]) # find deviation point from anchor point LIME explanations deviation_point_index = neighborhood_indices[anchorX_LC_argmax] x_deviation_index_shap.append(deviation_point_index) # columns_lipschitz will be reused so to avoid confusion naming convention should remain similar columns_lipschitz = ['instance', 'anchor_x_index', 'lc_coefficient_lime', 'x_deviation_index_lime', 'lc_coefficient_shap', 'x_deviation_index_shap', 'radiuses', 'neighborhood_size'] zippedList = list(zip(instances, anchor_x_index, lc_coefficient_lime, x_deviation_index_lime, lc_coefficient_shap, x_deviation_index_shap, radiuses, neighborhood_size)) return zippedList, columns_lipschitz ###Output _____no_output_____ ###Markdown Prepare points from testset ###Code X = pd.DataFrame(test) x_points = X.copy().values print("Testset") # display(X.head()) # radii = [1.00, 1.25] radii = [0.75] ###Output Testset ###Markdown 1. Lipschitz est. using explanations generated on logistic regression model ###Code print("LIME generated explanations") X_lime_exp = explanations_lime_lr.iloc[:,:-1].copy() # display(X_lime_exp.head()) print("SHAP generated explanations") X_shap_exp = explanations_shap_lr.iloc[:,:].copy() # display(X_shap_exp.head()) x_points_lime_exp = X_lime_exp.copy().values x_points_shap_exp = X_shap_exp.copy().values zippedList, columns_lipschitz = find_lipschitz_estimates(x_points, x_points_lime_exp, x_points_shap_exp, radii) lr_lipschitz = pd.DataFrame(zippedList, columns=columns_lipschitz) ###Output [0, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 2, 3, 4, 5, 6, 7, 8, 10, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 67, 68] [4, 5, 10, 12, 13, 21, 24, 46, 48, 49, 55, 57, 59, 62, 65] [0, 1, 4, 5, 7, 10, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 24, 30, 33, 35, 36, 38, 39, 43, 44, 45, 48, 49, 50, 53, 54, 56, 57, 61, 64, 67, 68] [0, 1, 4, 5, 6, 10, 12, 13, 17, 20, 21, 22, 23, 24, 27, 29, 30, 31, 35, 36, 41, 42, 44, 46, 48, 49, 50, 52, 54, 55, 56, 57, 59, 61, 62, 63, 67, 68] [0, 1, 2, 3, 4, 5, 6, 10, 12, 13, 14, 16, 17, 20, 21, 22, 23, 24, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 2, 3, 4, 5, 6, 10, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 4, 5, 6, 10, 12, 13, 14, 20, 21, 23, 24, 27, 29, 30, 32, 36, 41, 42, 44, 46, 48, 49, 52, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [0, 1, 3, 17, 18, 19, 20, 22, 24, 28, 35, 37, 38, 40, 43, 44, 45, 47, 50, 56, 58, 64, 67, 68] [0, 1, 15, 17, 18, 20, 22, 24, 31, 35, 43, 44, 45, 50, 54, 56, 64, 67, 68] [17] [0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 16, 17, 20, 21, 22, 23, 24, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 15, 17, 18, 20, 22, 35, 43, 44, 45, 50, 56, 64, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [5, 6, 7, 13, 14, 21, 23, 24, 27, 46, 55, 57, 59, 67] [0, 1, 3, 6, 9, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 24, 31, 33, 35, 39, 43, 44, 45, 47, 50, 53, 54, 56, 57, 58, 61, 64, 67, 68] [0, 1, 3, 5, 6, 11, 13, 14, 16, 17, 18, 20, 21, 22, 23, 24, 25, 29, 30, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 66, 67, 68] [0, 1, 3, 6, 8, 9, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 24, 25, 29, 30, 33, 35, 36, 38, 39, 40, 43, 44, 45, 47, 49, 50, 53, 54, 56, 57, 58, 61, 64, 66, 67, 68] [0, 1, 3, 8, 16, 18, 19, 20, 22, 24, 28, 35, 37, 38, 40, 43, 44, 45, 47, 50, 54, 56, 58, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 66, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 67, 68] [0, 1, 4, 5, 6, 7, 11, 13, 14, 15, 17, 18, 21, 22, 23, 24, 27, 29, 30, 32, 35, 36, 38, 41, 42, 44, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [1, 6, 13, 14, 17, 19, 21, 22, 25, 29, 30, 33, 36, 41, 49, 53, 54, 55, 57, 62] [] [0, 1, 4, 5, 6, 7, 11, 13, 14, 15, 18, 21, 22, 23, 24, 25, 29, 30, 31, 32, 35, 36, 41, 42, 44, 46, 48, 49, 50, 52, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [8, 20, 37, 38, 40, 45, 58] [0, 1, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 31, 32, 33, 35, 36, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 33, 34, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 4, 5, 6, 9, 11, 13, 14, 16, 18, 21, 22, 23, 25, 28, 30, 35, 38, 42, 43, 44, 45, 46, 50, 52, 54, 55, 56, 57, 64, 67, 68] [1, 5, 6, 7, 11, 13, 14, 22, 24, 25, 28, 30, 36, 41, 42, 46, 48, 49, 54, 55, 57, 59, 62] [0, 1, 3, 5, 6, 11, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 30, 31, 35, 36, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 64, 67, 68] [0, 1, 17, 18, 21, 23, 25, 31, 35, 37, 38, 43, 44, 45, 49, 51, 53, 54, 56, 64, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 28, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 31, 33, 34, 36, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 8, 18, 20, 21, 23, 25, 29, 35, 36, 38, 40, 43, 44, 45, 50, 56, 58, 64, 67, 68] [0, 1, 3, 5, 6, 8, 11, 13, 14, 18, 19, 20, 21, 22, 23, 24, 25, 29, 31, 32, 35, 36, 38, 40, 42, 43, 44, 45, 46, 48, 49, 50, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 16, 18, 19, 21, 23, 36, 43, 44, 45, 50, 54, 56, 61, 64, 67, 68] [0, 1, 8, 18, 19, 20, 21, 23, 25, 29, 36, 38, 39, 43, 44, 45, 47, 56, 58, 64, 67, 68] [1, 4, 5, 6, 7, 11, 13, 14, 17, 21, 22, 24, 25, 26, 28, 30, 31, 33, 34, 37, 42, 44, 46, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 63, 67, 68] [0, 1, 4, 5, 6, 7, 11, 13, 14, 17, 18, 21, 22, 23, 24, 25, 28, 30, 31, 32, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [0, 1, 3, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 25, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, 45, 46, 47, 48, 49, 50, 53, 54, 55, 56, 57, 58, 61, 62, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 28, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 66, 67, 68] [0, 1, 3, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 25, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, 45, 46, 47, 48, 49, 50, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 67, 68] [0, 1, 2, 4, 5, 6, 7, 11, 13, 14, 15, 17, 18, 21, 22, 23, 24, 25, 28, 30, 31, 32, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 65, 67, 68] [0, 8, 16, 18, 19, 20, 21, 23, 34, 36, 41, 44, 45, 46, 54, 56, 58, 64, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 21, 22, 23, 24, 25, 28, 30, 31, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 47, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 65, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 31, 33, 34, 35, 36, 37, 39, 42, 43, 44, 45, 46, 47, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 28, 30, 31, 32, 34, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [18, 21, 23, 35, 36, 45, 51, 56, 67, 68] [0, 1, 4, 5, 6, 7, 11, 13, 14, 18, 21, 22, 23, 24, 25, 28, 30, 32, 37, 43, 45, 47, 49, 50, 51, 54, 55, 56, 57, 59, 61, 62, 63, 67, 68] [0, 1, 3, 5, 6, 11, 13, 14, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 30, 31, 34, 35, 36, 37, 42, 43, 44, 45, 46, 47, 49, 50, 51, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 9, 11, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 30, 31, 32, 33, 34, 35, 36, 37, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 66, 67, 68] [0, 1, 2, 4, 5, 6, 7, 11, 13, 14, 15, 17, 18, 21, 22, 23, 24, 25, 26, 28, 30, 31, 32, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 47, 49, 50, 51, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 65, 67, 68] ###Markdown 2. Lipschitz est. using explanations generated on random forest model ###Code print("LIME generated explanations") X_lime_exp = explanations_lime_rf.iloc[:,:-1].copy() # display(X_lime_exp.head()) print("SHAP generated explanations") X_shap_exp = explanations_shap_rf.iloc[:,:].copy() # display(X_shap_exp.head()) x_points_lime_exp = X_lime_exp.copy().values x_points_shap_exp = X_shap_exp.copy().values zippedList, columns_lipschitz = find_lipschitz_estimates(x_points, x_points_lime_exp, x_points_shap_exp, radii) rf_lipschitz = pd.DataFrame(zippedList, columns=columns_lipschitz) ###Output [0, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 2, 3, 4, 5, 6, 7, 8, 10, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 67, 68] [4, 5, 10, 12, 13, 21, 24, 46, 48, 49, 55, 57, 59, 62, 65] [0, 1, 4, 5, 7, 10, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 24, 30, 33, 35, 36, 38, 39, 43, 44, 45, 48, 49, 50, 53, 54, 56, 57, 61, 64, 67, 68] [0, 1, 4, 5, 6, 10, 12, 13, 17, 20, 21, 22, 23, 24, 27, 29, 30, 31, 35, 36, 41, 42, 44, 46, 48, 49, 50, 52, 54, 55, 56, 57, 59, 61, 62, 63, 67, 68] [0, 1, 2, 3, 4, 5, 6, 10, 12, 13, 14, 16, 17, 20, 21, 22, 23, 24, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 2, 3, 4, 5, 6, 10, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 4, 5, 6, 10, 12, 13, 14, 20, 21, 23, 24, 27, 29, 30, 32, 36, 41, 42, 44, 46, 48, 49, 52, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [0, 1, 3, 17, 18, 19, 20, 22, 24, 28, 35, 37, 38, 40, 43, 44, 45, 47, 50, 56, 58, 64, 67, 68] [0, 1, 15, 17, 18, 20, 22, 24, 31, 35, 43, 44, 45, 50, 54, 56, 64, 67, 68] [17] [0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 16, 17, 20, 21, 22, 23, 24, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 15, 17, 18, 20, 22, 35, 43, 44, 45, 50, 56, 64, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [5, 6, 7, 13, 14, 21, 23, 24, 27, 46, 55, 57, 59, 67] [0, 1, 3, 6, 9, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 24, 31, 33, 35, 39, 43, 44, 45, 47, 50, 53, 54, 56, 57, 58, 61, 64, 67, 68] [0, 1, 3, 5, 6, 11, 13, 14, 16, 17, 18, 20, 21, 22, 23, 24, 25, 29, 30, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 66, 67, 68] [0, 1, 3, 6, 8, 9, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 24, 25, 29, 30, 33, 35, 36, 38, 39, 40, 43, 44, 45, 47, 49, 50, 53, 54, 56, 57, 58, 61, 64, 66, 67, 68] [0, 1, 3, 8, 16, 18, 19, 20, 22, 24, 28, 35, 37, 38, 40, 43, 44, 45, 47, 50, 54, 56, 58, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 66, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 27, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 67, 68] [0, 1, 4, 5, 6, 7, 11, 13, 14, 15, 17, 18, 21, 22, 23, 24, 27, 29, 30, 32, 35, 36, 38, 41, 42, 44, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 40, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 65, 67, 68] [1, 6, 13, 14, 17, 19, 21, 22, 25, 29, 30, 33, 36, 41, 49, 53, 54, 55, 57, 62] [] [0, 1, 4, 5, 6, 7, 11, 13, 14, 15, 18, 21, 22, 23, 24, 25, 29, 30, 31, 32, 35, 36, 41, 42, 44, 46, 48, 49, 50, 52, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [8, 20, 37, 38, 40, 45, 58] [0, 1, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 31, 32, 33, 35, 36, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 33, 34, 35, 36, 38, 41, 42, 43, 44, 45, 46, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 4, 5, 6, 9, 11, 13, 14, 16, 18, 21, 22, 23, 25, 28, 30, 35, 38, 42, 43, 44, 45, 46, 50, 52, 54, 55, 56, 57, 64, 67, 68] [1, 5, 6, 7, 11, 13, 14, 22, 24, 25, 28, 30, 36, 41, 42, 46, 48, 49, 54, 55, 57, 59, 62] [0, 1, 3, 5, 6, 11, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 30, 31, 35, 36, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 64, 67, 68] [0, 1, 17, 18, 21, 23, 25, 31, 35, 37, 38, 43, 44, 45, 49, 51, 53, 54, 56, 64, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 28, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 31, 33, 34, 36, 41, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 8, 18, 20, 21, 23, 25, 29, 35, 36, 38, 40, 43, 44, 45, 50, 56, 58, 64, 67, 68] [0, 1, 3, 5, 6, 8, 11, 13, 14, 18, 19, 20, 21, 22, 23, 24, 25, 29, 31, 32, 35, 36, 38, 40, 42, 43, 44, 45, 46, 48, 49, 50, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 16, 18, 19, 21, 23, 36, 43, 44, 45, 50, 54, 56, 61, 64, 67, 68] [0, 1, 8, 18, 19, 20, 21, 23, 25, 29, 36, 38, 39, 43, 44, 45, 47, 56, 58, 64, 67, 68] [1, 4, 5, 6, 7, 11, 13, 14, 17, 21, 22, 24, 25, 26, 28, 30, 31, 33, 34, 37, 42, 44, 46, 48, 49, 50, 53, 54, 55, 56, 57, 59, 61, 62, 63, 67, 68] [0, 1, 4, 5, 6, 7, 11, 13, 14, 17, 18, 21, 22, 23, 24, 25, 28, 30, 31, 32, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 67, 68] [0, 1, 3, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 25, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, 45, 46, 47, 48, 49, 50, 53, 54, 55, 56, 57, 58, 61, 62, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 28, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 64, 66, 67, 68] [0, 1, 3, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 25, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 43, 44, 45, 46, 47, 48, 49, 50, 53, 54, 55, 56, 57, 58, 59, 61, 62, 64, 67, 68] [0, 1, 2, 4, 5, 6, 7, 11, 13, 14, 15, 17, 18, 21, 22, 23, 24, 25, 28, 30, 31, 32, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 65, 67, 68] [0, 8, 16, 18, 19, 20, 21, 23, 34, 36, 41, 44, 45, 46, 54, 56, 58, 64, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 21, 22, 23, 24, 25, 28, 30, 31, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 47, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 65, 67, 68] [0, 1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 30, 31, 33, 34, 35, 36, 37, 39, 42, 43, 44, 45, 46, 47, 49, 50, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 28, 30, 31, 32, 34, 36, 37, 38, 39, 40, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [18, 21, 23, 35, 36, 45, 51, 56, 67, 68] [0, 1, 4, 5, 6, 7, 11, 13, 14, 18, 21, 22, 23, 24, 25, 28, 30, 32, 37, 43, 45, 47, 49, 50, 51, 54, 55, 56, 57, 59, 61, 62, 63, 67, 68] [0, 1, 3, 5, 6, 11, 13, 14, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 30, 31, 34, 35, 36, 37, 42, 43, 44, 45, 46, 47, 49, 50, 51, 54, 55, 56, 57, 59, 61, 62, 63, 64, 67, 68] [0, 1, 3, 4, 5, 6, 7, 9, 11, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 30, 31, 32, 33, 34, 35, 36, 37, 39, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 66, 67, 68] [0, 1, 2, 4, 5, 6, 7, 11, 13, 14, 15, 17, 18, 21, 22, 23, 24, 25, 26, 28, 30, 31, 32, 33, 34, 36, 37, 39, 42, 43, 44, 45, 46, 47, 49, 50, 51, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 65, 67, 68] ###Markdown 1. Lipschitz est. visualizations computed on logistic regression model ###Code epsilon1 = lr_lipschitz[lr_lipschitz['radiuses'] == 1.00] epsilon125 = lr_lipschitz[lr_lipschitz['radiuses'] == 1.25] # display(epsilon1.head()) # display(epsilon125.head()) print("Lipschitz estimates on logistic regression model.") epsilon1_lc_lime_aggre = np.mean(epsilon1['lc_coefficient_lime']) epsilon1_lc_shap_aggre = np.mean(epsilon1['lc_coefficient_shap']) print("\nLIME, epsilon 1.00, Aggregated L(x) = ", epsilon1_lc_lime_aggre) print("SHAP, epsilon 1.00, Aggregated L(x) = ", epsilon1_lc_shap_aggre) epsilon125_lc_lime_aggre = np.mean(epsilon125['lc_coefficient_lime']) epsilon125_lc_shap_aggre = np.mean(epsilon125['lc_coefficient_shap']) print("\nLIME, epsilon 1.25, Aggregated L(x) = ", epsilon125_lc_lime_aggre) print("SHAP, epsilon 1.25, Aggregated L(x) = ", epsilon125_lc_shap_aggre) ###Output Lipschitz estimates on logistic regression model. LIME, epsilon 1.00, Aggregated L(x) = nan SHAP, epsilon 1.00, Aggregated L(x) = nan LIME, epsilon 1.25, Aggregated L(x) = nan SHAP, epsilon 1.25, Aggregated L(x) = nan ###Markdown 2. Lipschitz est. visualizations computed on random forest model ###Code epsilon1 = rf_lipschitz[rf_lipschitz['radiuses'] == 1.00] epsilon125 = rf_lipschitz[rf_lipschitz['radiuses'] == 1.25] # display(epsilon075.head()) # display(epsilon1.head()) # display(epsilon125.head()) print("Lipschitz estimates on random forest model.") epsilon1_lc_lime_aggre = np.mean(epsilon1['lc_coefficient_lime']) epsilon1_lc_shap_aggre = np.mean(epsilon1['lc_coefficient_shap']) print("\nLIME, epsilon 1.00, Aggregated L(x) = ", epsilon1_lc_lime_aggre) print("SHAP, epsilon 1.00, Aggregated L(x) = ", epsilon1_lc_shap_aggre) epsilon125_lc_lime_aggre = np.mean(epsilon125['lc_coefficient_lime']) epsilon125_lc_shap_aggre = np.mean(epsilon125['lc_coefficient_shap']) print("\nLIME, epsilon 1.25, Aggregated L(x) = ", epsilon125_lc_lime_aggre) print("SHAP, epsilon 1.25, Aggregated L(x) = ", epsilon125_lc_shap_aggre) ###Output Lipschitz estimates on random forest model. LIME, epsilon 1.00, Aggregated L(x) = 0.1704131061013217 SHAP, epsilon 1.00, Aggregated L(x) = 0.09775652916250081 LIME, epsilon 1.25, Aggregated L(x) = 0.1704131061013217 SHAP, epsilon 1.25, Aggregated L(x) = 0.09775652916250081 ###Markdown Visualizations ###Code df1 = epsilon075.loc[:, ['lc_coefficient_lime']] df1.rename(columns={'lc_coefficient_lime': 'Lipschitz Estimates'}, inplace=True) df1['method'] = 'LIME' df1['Dataset'] = 'Ionoshpere' df2 = epsilon075.loc[:, ['lc_coefficient_shap']] df2.rename(columns={'lc_coefficient_shap': 'Lipschitz Estimates'}, inplace=True) df2['method'] = 'SHAP' df2['Dataset'] = 'Ionoshpere' df = df1.append(df2) ax = sns.boxplot(x='method', y="Lipschitz Estimates", data=df) ax = sns.boxplot(x="Dataset", y="Lipschitz Estimates", hue="method", data=df) sns.despine(offset=10, trim=True) ###Output _____no_output_____ ###Markdown LIME visualizations by single points ###Code explainer_lime = LimeTabularExplainer(train, mode = 'classification', training_labels = labels_train, feature_names=feature_names, verbose=False, class_names=target_names, feature_selection='auto', discretize_continuous=True) x_instance = test[anchor_index] LR_exp_lime = explainer_lime.explain_instance(x_instance, LR_iris.predict_proba, labels=np.unique(iris.target), top_labels=None, num_features=len(x_instance), num_samples=6000) LR_exp_lime.show_in_notebook() x_instance = test[similar_point_index] LR_exp_lime = explainer_lime.explain_instance(x_instance, LR_iris.predict_proba, labels=np.unique(iris.target), top_labels=None, num_features=len(x_instance), num_samples=6000) LR_exp_lime.show_in_notebook() i = np.random.randint(0, test.shape[0]) i = 0 LR_exp_lime_map = LR_exp_lime.as_map() # pprint(LR_exp_lime_map) print('Predicted class for i:', labels_pred_lr[i]) LR_exp_lime_list = LR_exp_lime.as_list(label=labels_pred_lr[i]) # pprint(LR_exp_lime_list) ###Output _____no_output_____ ###Markdown Conclusions ###Code lr_lime_iris = [2.657, 3.393, 1.495] rf_lime_iris = [3.010, 3.783, 1.767] lr_shap_iris = [2.716, 3.512, 1.463] rf_shap_iris = [1.969, 3.546, 2.136] find_min_vector = np.array([lr_lime_iris, rf_lime_iris, lr_shap_iris, rf_shap_iris]) np.amin(find_min_vector, axis=0) from sklearn.linear_model import Ridge import numpy as np n_samples, n_features = 10, 5 rng = np.random.RandomState(0) y = rng.randn(n_samples) X = rng.randn(n_samples, n_features) clf = Ridge(alpha=1.0) clf.fit(X, y) ###Output _____no_output_____
docs/Python/Pandas/MonthBegin_and_MonthEnd.ipynb
###Markdown Pandas TimeSeries MonthBegin and MonthEnd ###Code import pandas as pd from pandas.tseries.offsets import MonthBegin, MonthEnd ###Output _____no_output_____ ###Markdown MonthEndHelpful when figuring out whether month ends on 28th, 29th, 30th, 31st. ###Code todays_date = '2021-02-07' month_end_date = pd.to_datetime(todays_date) + MonthEnd(1) print(month_end_date) ###Output 2021-02-28 00:00:00 ###Markdown MonthBeginHelpful when figuring out when current/previous/next MonthBegin. ###Code month_start_date = pd.to_datetime(todays_date) + MonthBegin(-1) print(month_start_date) next_month_start_date = pd.to_datetime(todays_date) + MonthBegin(1) print(next_month_start_date) ###Output 2021-03-01 00:00:00
10 - Model Selection/K_Fold_Cross_Validation.ipynb
###Markdown ROC curves and Area Under the CurveAn ROC curve is the most commonly used way to visualize the performance of a binary classifier, and AUC is (arguably) the best way to summarize its performance in a single number. As such, gaining a deep understanding of ROC curves and AUC is beneficial for data scientists, machine learning practitioners, and medical researchers (among others). ###Code from sklearn.metrics import (confusion_matrix, precision_recall_curve, auc, roc_curve, recall_score, classification_report, f1_score, precision_recall_fscore_support) fpr, tpr, thresholds = roc_curve(y_test, y_pred) roc_auc = auc(fpr, tpr) plt.title('Receiver Operating Characteristic') plt.plot(fpr, tpr, label='AUC = %0.4f'% roc_auc) plt.legend(loc='lower right') plt.plot([0,1],[0,1],'r--') plt.xlim([-0.001, 1]) plt.ylim([0, 1.001]) plt.ylabel('True Positive Rate') plt.xlabel('False Positive Rate') plt.show(); ###Output _____no_output_____