content
stringlengths 6
1.05M
|
|---|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernel_info:
# name: python3
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # WeatherPy
# ----
#
# #### Note
# * Instructions have been included for each segment. You do not have to follow them exactly, but they are included to help you think through the steps.
# Observations/Analysis:
#
# 1) Obviously the only variable that is decently correlated with latitude is maximum temperature: as cities move away from the equator their maximum temperatures decrease. No other variable was correlated strongly enough with latitude to suggest a meaningful relationship. Temperature is not simply determined by solar radiation and angles, but it can be inferred that it is much less complex than how humidity, cloud cover, and wind speed are determined.
#
# 2) Interestingly, for every failed correlation, it was much weaker in the northern hemisphere than in the southern hemisphere. Even though there was no correlation between latitude and humidity/cloudiness/wind speed in either hemisphere, it was noticeably "stronger" in the south. The southern hemisphere has much less land than the northern hemisphere, and while this no doubt affects the climate in myriad ways, the explanation might be simpler. There is less land, therefore fewer cities, therefore less data, therefore any regression will inherently be stronger because it is a smaller sample.
#
# 3) There are some minor things that are noticeable, even if other plots weren't correlated. For example, when it comes to humidity and latitude, in both the nothern and southern hemispheres, cities appear (but it's not suggested by regression) to have a lower humidity around |30| degrees. This tracks with the fact that this is typically where most of the Earth's deserts appear, thanks to being on convergent zones between the Ferrell and Hadley Cells. But for the other two variables, no clear patterns (even if weak) are discernable.
#
# +
# Dependencies and Setup
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import requests
import time
from scipy.stats import linregress
# Import API key
from api_keys import weather_api_key
# Incorporated citipy to determine city based on latitude and longitude
from citipy import citipy
# Range of latitudes and longitudes
lat_range = (-90, 90)
lng_range = (-180, 180)
# -
# ## Generate Cities List
# +
# List for holding lat_lngs and cities and countries
lat_lngs = []
cities = []
countries = []
# Create a set of random lat and lng combinations
lats = np.random.uniform(lat_range[0], lat_range[1], size=1500)
lngs = np.random.uniform(lng_range[0], lng_range[1], size=1500)
lat_lngs = zip(lats, lngs)
# Identify nearest city for each lat, lng combination, and the country code for that same lat, lng combination
for lat_lng in lat_lngs:
city = citipy.nearest_city(lat_lng[0], lat_lng[1]).city_name
country = citipy.nearest_city(lat_lng[0], lat_lng[1]).country_code
# If the city is unique, then add it to a our cities list
# add the country code (made uppercase) into the countries list
if city not in cities:
cities.append(city)
countries.append(country.upper())
# Print the city count to confirm sufficient count
len(cities)
# -
# create a dataframe with empty columns of all the data we'll want
weather_df = pd.DataFrame({"City": cities, "Lat": "", "Lng": "", "Max Temp": "",
"Humidity": "", "Cloudiness": "", "Wind Speed": "",
"Country": countries, "Date": ""})
weather_df.head()
# ### Perform API Calls
# * Perform a weather check on each city using a series of successive API calls.
# * Include a print log of each city as it'sbeing processed (with the city number and city name).
#
# +
#base url
url = "http://api.openweathermap.org/data/2.5/weather?"
blurb = "-"*29
#counters
recordnum = 1
setnum = 1
print(f"Beginning Data Retrieval")
print(f"{blurb}")
#iterate through the dataframe, for each index/row, take the city and country to form the query
#use them along with the api key and making sure the units are in imperial
for index, row in weather_df.iterrows():
query = url + "appid=" + weather_api_key + "&q=" + row["City"] + "," + row["Country"] + "&units=imperial"
#create a response using requests.get (and make sure it is converted into json)
response = requests.get(query).json()
#for each api call, attempt to retrieve the coordinates, temperature, humidity, etc
try:
print(f"Processing Record {recordnum} of Set {setnum} | {response['name']}")
weather_df.loc[index, "Lat"] = response["coord"]["lat"]
weather_df.loc[index, "Lng"] = response["coord"]["lon"]
weather_df.loc[index, "Max Temp"] = response["main"]["temp_max"]
weather_df.loc[index, "Humidity"] = response["main"]["humidity"]
weather_df.loc[index, "Cloudiness"] = response["clouds"]["all"]
weather_df.loc[index, "Wind Speed"] = response["wind"]["speed"]
weather_df.loc[index, "Date"] = response["dt"]
#increment the counter
recordnum += 1
#if the city is not in the database, or if the data cannot be found, except
except (KeyError, IndexError):
print(f"City not found. Skipping...")
#conditions for the counters, so that no more than 50 cities can be in each set
if recordnum == 51:
setnum += 1
recordnum = 1
print(f"{blurb}")
print(f"Data Retrieval Complete")
print(f"{blurb}")
# -
# ### Convert Raw Data to DataFrame
# * Export the city data into a .csv.
# * Display the DataFrame
#clean up the dataframe by dropping any rows that are missing data
weather_df["Lat"] = weather_df["Lat"].replace("", np.nan)
weather_df = weather_df.dropna(how="any")
#name the index column and save the dataframe as a csv file
weather_df.index.name = "City_ID"
weather_df.to_csv("../Output/WeatherDatabyCity.csv")
#make sure no more data is missing
weather_df.count()
weather_df.head()
# ## Inspect the data and remove the cities where the humidity > 100%.
# ----
# Skip this step if there are no cities that have humidity > 100%.
# +
#there are no cities with a humidity above 100
#still convert the object data of these columns into numeric
weather_df["Lat"] = weather_df["Lat"].apply(pd.to_numeric, errors="coerce")
weather_df["Lng"] = weather_df["Lng"].apply(pd.to_numeric, errors="coerce")
weather_df["Max Temp"] = weather_df["Max Temp"].apply(pd.to_numeric, errors="coerce")
weather_df["Humidity"] = weather_df["Humidity"].apply(pd.to_numeric, errors="coerce")
weather_df["Cloudiness"] = weather_df["Cloudiness"].apply(pd.to_numeric, errors="coerce")
weather_df["Wind Speed"] = weather_df["Wind Speed"].apply(pd.to_numeric, errors="coerce")
weather_df["Date"] = weather_df["Date"].apply(pd.to_numeric, errors="coerce")
#so that we can check the max value of the humidity column
weather_df.describe()
# -
# Get the indices of cities that have humidity over 100%.
index_label = weather_df[weather_df["Humidity"] > 100].index.tolist()
index_label
# +
# Make a new dataframe and drop all humidity outliers (if there are any) by index
city_data = weather_df
for x in index_label:
city_data.drop(x)
#save the new (and functionally identical) dataframe to a csv file
city_data.to_csv("../Output/city_data.csv")
city_data.head()
# -
# ## Plotting the Data
# * Use proper labeling of the plots using plot titles (including date of analysis) and axes labels.
# * Save the plotted figures as .pngs.
# ## Latitude vs. Temperature Plot
# +
#use matplotlib to create scatter plots, the code is basically the same each time, only the variables change
#facecolor="4C92C3"
plt.scatter(city_data["Lat"], city_data["Max Temp"], marker="o")
#make sure to create a title, and label the axes, and create a grid
plt.title(f"City Latitude vs. Max Temperature (7/20/2020)")
plt.ylabel("Max Temperature (F)")
plt.xlabel("Latitude")
plt.grid(True)
#save the scatter plot as an image
plt.savefig("../Output/Lat_vs_Temp.png")
#repeat this process for the next 4 scatter plots
# -
# A scatter plot, using matplotlib, testing the correlation between a city's latitude and its maximum temperature (F)
# Shows that cities closer to the equator do tend to have a higher maxmimum temperature
# ## Latitude vs. Humidity Plot
# +
plt.scatter(city_data["Lat"], city_data["Humidity"], marker="o")
plt.title(f"City Latitude vs. Humidity (7/20/2020)")
plt.ylabel("Humidity (%)")
plt.xlabel("Latitude")
plt.grid(True)
plt.savefig("../Output/Lat_vs_Humid.png")
# -
# A scatter plot, using matplotlib, testing the correlation between a city's latitude and its humidity
# Does not show a clear correlation between a city's latitude and its humidity
# Although there is a slight shape that suggests that cities around 30-50 N and (slightly less so for S) have lower humidities than other cities
# This is generally where the deserts of Earth exist (and deserts are bigger in the Northern Hemisphere, which explains the uneven distribution of this particular phenomenon between hemispheres)
# ## Latitude vs. Cloudiness Plot
# +
plt.scatter(city_data["Lat"], city_data["Cloudiness"], marker="o")
plt.title(f"City Latitude vs. Cloudiness (7/20/2020)")
plt.ylabel("Cloudiness (%)")
plt.xlabel("Latitude")
plt.grid(True)
plt.savefig("../Output/Lat_vs_Cloud.png")
# -
# A scatter plot, using matplotlib, testing the correlation between a city's latitude and its cloud cover percentage
# Despite there being a clear shape, its difficult to determine what it suggests, as otherwise it appears totally random how much cloud cover a city will get depending on its latitude
# ## Latitude vs. Wind Speed Plot
# +
plt.scatter(city_data["Lat"], city_data["Wind Speed"], marker="o")
plt.title(f"City Latitude vs. Wind Speed (7/20/2020)")
plt.ylabel("Wind Speed (mph)")
plt.xlabel("Latitude")
plt.grid(True)
plt.savefig("../Output/Lat_vs_Wind.png")
# -
# A scatter plot, using matplotlib, testing the correlation between a city's latitude and its wind speed (mph)
# Does not show a strong correlation, small suggestion that cities closer to the equator might have slightly higher windspeeds, which can be explained by the Corriolis Effect, but other factors (such as ocean currents, landmass, and if a city is on an island) have to be taken into consideration
# ## Linear Regression
# OPTIONAL: Create a function to create Linear Regression plots
# using linregress and scipy.stats
# determine the correlation coefficient using pearsonr, and use that to get the r-squared value
# use the linregress variables to create an equation for the regression line
# display both the r squared value and the regression line equation
# plot the regression line onto the scatter plot that calls this function
def regress(x,y):
import scipy.stats as st
corr = st.pearsonr(x, y)
corr1 = corr[0]
rsquare = round(corr1**2,6)
print(f"The r-squared is: {rsquare}")
(slope, intercept, rvalue, pvalue, stderr) = linregress(x, y)
regress_values = x * slope + intercept
line_eq = "y = " + str(round(slope,2)) + "x + " + str(round(intercept,2))
plt.plot(x,regress_values,"r-")
print(f"The regression line is: {line_eq}")
# Create Northern and Southern Hemisphere DataFrames
# search only for northern hemisphere cities, and then only southern hemisphere cities
# both include the equator
northern_df = city_data.loc[(city_data["Lat"] >= 0)]
southern_df = city_data.loc[(city_data["Lat"] <= 0)]
# #### Northern Hemisphere - Max Temp vs. Latitude Linear Regression
# +
# create a scatter plot using the relevant columns from the data frames, and labeling the axes
lat = northern_df["Lat"]
temp = northern_df["Max Temp"]
plt.scatter(lat, temp, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Max Temp")
# call the regress function to output the numbers we want and to plot the regression line
regress(lat,temp)
# the rest of the regression lines will use the same basic code template
# -
# Using a python function to run a linear regression analysis on the scatter plot for Northern Hemisphere cities against their maximum temperatures
# The line shows a moderate correlation: as cities appear farther north their maximum temperature decreases
# #### Southern Hemisphere - Max Temp vs. Latitude Linear Regression
# +
lat = southern_df["Lat"]
temp = southern_df["Max Temp"]
plt.scatter(lat, temp, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Max Temp")
regress(lat,temp)
# -
# Using a python function to run a linear regression analysis on the scatter plot for Southern Hemisphere cities against their maximum temperatures
# The line shows a moderate correlation: as cities appear farther south their maximum temperature decreases
# #### Northern Hemisphere - Humidity (%) vs. Latitude Linear Regression
# +
lat = northern_df["Lat"]
hum = northern_df["Humidity"]
plt.scatter(lat, hum, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Humidity")
regress(lat,hum)
# -
# Using a python function to run a linear regression analysis on the scatter plot for Nothern Hemisphere cities against their humidity
# The line shows practically no correlation, humidity cannot be predicted just by changing temperatures along latitudes, it appears to be a more complex phenomenon
# #### Southern Hemisphere - Humidity (%) vs. Latitude Linear Regression
# +
lat = southern_df["Lat"]
hum = southern_df["Humidity"]
plt.scatter(lat, hum, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Humidity")
regress(lat,hum)
# -
# Using a python function to run a linear regression analysis on the scatter plot for Southern Hemisphere cities against their humidity
# The line shows a very slightly stronger correlation than its northern counterpart, but still not enough to suggest any kind of meaningful relationship between humidity and latitude
# #### Northern Hemisphere - Cloudiness (%) vs. Latitude Linear Regression
# +
lat = northern_df["Lat"]
cloud = northern_df["Cloudiness"]
plt.scatter(lat, cloud, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Cloudiness")
regress(lat,cloud)
# -
# Using a python function to run a linear regression analysis on the scatter plot for Northern Hemisphere cities against their cloud cover percentage
# The line shows absolutely no correlation at all, clouds are not dependent on latitude to form
# #### Southern Hemisphere - Cloudiness (%) vs. Latitude Linear Regression
# +
lat = southern_df["Lat"]
cloud = southern_df["Cloudiness"]
plt.scatter(lat, cloud, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Cloudiness")
regress(lat,cloud)
# -
# Using a python function to run a linear regression analysis on the scatter plot for Southern Hemisphere cities against their cloud cover percentage
# The line again (coincidentally) shows a slightly stronger correlation than its northern counterpart, but it still does not suggest any kind of relationship
# #### Northern Hemisphere - Wind Speed (mph) vs. Latitude Linear Regression
# +
lat = northern_df["Lat"]
wind = northern_df["Wind Speed"]
plt.scatter(lat, wind, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Wind Speed")
regress(lat,wind)
# -
# Using a python function to run a linear regression analysis on the scatter plot for Northern Hemisphere cities against their wind speed
# The line shows no correlation between latitude and wind speed
# #### Southern Hemisphere - Wind Speed (mph) vs. Latitude Linear Regression
# +
lat = southern_df["Lat"]
wind = southern_df["Wind Speed"]
plt.scatter(lat, wind, marker="o")
plt.xlabel("Latitude")
plt.ylabel("Wind Speed")
regress(lat,wind)
# -
# Using a python function to run a linear regression analysis on the scatter plot for Southern Hemisphere cities against their wind speed
# The line shows no correlation between latitude and wind speed, but it is stronger than the nothern one
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import ipyaladin as ipyal
# ## Display table result of an astroquery request
from astroquery.simbad import Simbad
import astropy.units as u
table = Simbad.query_region("Messier 1", radius=0.03 * u.deg)
aladin = ipyal.Aladin(fov= 0.4, target= 'Messier 1')
aladin
aladin.add_table(table)
# ## Display Astropy table created from scratch
# +
from astropy.table import QTable
import astropy.units as u
import numpy as np
ra = [83.63451584700, 83.61368056017, 83.58780251600]
dec = [22.05652591227, 21.97517807639, 21.99277764451]
name = ['Gaia EDR3 3403818589184411648', 'Gaia EDR3 3403817661471500416', 'Gaia EDR3 3403817936349408000']
parallax = [1.7703, 0.5112, 0.3735] * u.mas
t = QTable([ra, dec, name, parallax],
names=('ra', 'dec', 'name', 'parallax'),
meta={'name': 'my sample table'})
# -
aladin.add_table(t)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: conda_python3
# language: python
# name: conda_python3
# ---
# +
import boto3
import sagemaker
import pandas as pd
region = boto3.Session().region_name
sagemaker_session = sagemaker.session.Session()
role = sagemaker.get_execution_role()
default_bucket = sagemaker_session.default_bucket()
model_package_group_name = f"FraudScratchModelPackageGroupName"
# -
# ## 데이터 세트 로딩 및 S3 업로드
data_dir = '../data'
df_train = pd.read_csv(f"{data_dir}/train.csv", index_col=0)
df_test = pd.read_csv(f"{data_dir}/test.csv", index_col=0)
# 이제 데이터를 디폴트 버킷으로 업로드합니다. `input_data_uri` 변수를 통해 데이터셋의 위치를 저장하였습니다.
local_path = "../data/train.csv"
data_prefix = 'fraud2scratch'
base_uri = f"s3://{default_bucket}/{data_prefix}"
input_data_uri = sagemaker.s3.S3Uploader.upload(
local_path=local_path,
desired_s3_uri=base_uri,
)
print(input_data_uri)
# 모델 생성 후 배치변환 추론을 실행할 때 사용할 두번째 데이터셋을 다운로드 합니다. 본 파일의 경로를 `batch_data_uri`에 저장합니다.
# +
local_path = "../data/test.csv"
base_uri = f"s3://{default_bucket}/abalone"
batch_data_uri = sagemaker.s3.S3Uploader.upload(
local_path=local_path,
desired_s3_uri=base_uri,
)
print(batch_data_uri)
# -
# ### 파이프라인 실행을 위한 파라미터 정의
#
#
# ## Preprocessing File 작성
# +
import os
base_preproc_dir = 'opt/ml/processing'
os.makedirs(base_preproc_dir, exist_ok=True)
base_input_dir = 'opt/ml/processing/input'
os.makedirs(base_input_dir, exist_ok=True)
base_train_dir = 'opt/ml/processing/train'
os.makedirs(base_train_dir, exist_ok=True)
base_validation_dir = 'opt/ml/processing/validation'
os.makedirs(base_validation_dir, exist_ok=True)
base_test_dir = 'opt/ml/processing/test'
os.makedirs(base_test_dir, exist_ok=True)
# # !mkdir -p abalone
s3_input_data = 's3://sagemaker-ap-northeast-2-057716757052/abalone/abalone-dataset.csv'
# ! aws s3 cp {s3_input_data} {base_input_dir}
# +
# df = pd.read_csv(base_input_dir + "/abalone-dataset.csv")
# df
# df_train.info()
# -
# ## 데이터 피쳐 전처리 스크래치 작업
# +
# df_train.info()
import numpy as np
cols = df_train.columns
cols = ['incident_month', 'customer_age', 'incident_hour', 'months_as_customer','injury_claim'
]
df2 = df_train[cols].reset_index()
df2.to_csv('opt/ml/processing/input/fraud-dataset.csv', index=False)
dataset_file_path = 'input/fraud-dataset.csv'
float_cols = df2.select_dtypes(include=['float']).columns.values
int_cols = df2.select_dtypes(include=['int']).columns.values
numeric_cols = np.concatenate((float_cols, int_cols), axis=0).tolist()
numeric_cols
obj_cols = df2.select_dtypes(include=['object']).columns.values.tolist()
obj_cols
# -
# ! python preprocessing.py --base_dir {base_preproc_dir} --dataset_file_path {dataset_file_path}
# ### 특성공학(Feature Engineering)을 위한 프로세싱 단계 정의
#
#
# +
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
processing_instance_type = ParameterString(
name="ProcessingInstanceType",
default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
name="TrainingInstanceType",
default_value="ml.m5.xlarge"
)
model_approval_status = ParameterString(
name="ModelApprovalStatus",
default_value="PendingManualApproval"
)
input_data = ParameterString(
name="InputData",
default_value=input_data_uri,
)
batch_data = ParameterString(
name="BatchData",
default_value=batch_data_uri,
)
# -
# 다음으로 프로세싱을 위한 `SKLearnProcessor`의 인스턴스를 생성합니다. 이 인스턴스는 `ProcessingStep`에서 사용합니다.
#
# 본 노트북에서 계속 사용할 `framework_version`값을 지정합니다.
#
# `sklearn_processor` 인스턴스의 생성시 `processing_instance_type`과 `processing_instance_count` 파라미터가 사용된 것을 확인합니다.
#
# +
from sagemaker.sklearn.processing import SKLearnProcessor
framework_version = "0.23-1"
sklearn_processor = SKLearnProcessor(
framework_version=framework_version,
instance_type=processing_instance_type,
instance_count=processing_instance_count,
base_job_name="sklearn-abalone-process",
role=role,
)
# -
# 프로세싱 단계의 마지막으로, 방금 생성한 프로세서 인스턴스와 입출력 채널을 지정하고 `ProcessingStep`을 생성합니다. `code`값을 통해 앞서 지정한 파일을 전달하고 있습니다. 파이프라인이 실행되면 해당 파이썬 스크립트가 실행될 것입니다. 이 단계는 SageMaker 파이썬 SDK에서 Processor 인스턴스의 `run`명령을 실행하는 것과 유사합니다.
#
# `ProcessingStep`생성시 사용할 입력데이터 지정을 위해 `input_data`파라미터를 이용하는 것을 확인합니다. 인스턴스 실행시 이 파라미터에 지정된 데이터를 이용하여 처리가 실행될 것입니다.
#
# 또, `"train"`, `"validation"`, `"test"` 채널을 통해 프로세싱 작업의 출력이 설정된 것을 확인합니다. 이어지는 단계에서 `properties`속성을 통해 이 값을 참조하고 사용하게 됩니다. 구체적으로, 학습단계를 정의하는 시점에 사용될 것입니다.
#
input_data
# +
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
step_process = ProcessingStep(
name="AbaloneProcess",
processor=sklearn_processor,
inputs=[
ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
],
outputs=[
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
],
code="abalone/preprocessing.py",
)
# -
# 
# ### 모델 학습을 위한 학습단계 정의
#
# 본 단계에서는 SageMaker의 [XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) 알고리즘을 이용하여 학습을 진행할 것입니다. XGBoost 알고리즘을 이용하도록 Estimator를 구성합니다. 보편적인 학습스크립트를 이용하여 입력 채널에서 정의한 학습데이터를 로드하고, 하이퍼파라미터 설정을 통해 학습을 설정하고, 모델을 학습한 후 `model_dir`경로에 학습된 모델을 저장합니다. 저장된 모델은 이후 호스팅을 위해 사용됩니다.
#
# 학습된 모델이 추출되어 저장될 경로 또한 명시되었습니다.
#
# `training_instance_type`파라미터가 사용된 것을 확인합니다. 이 값은 본 예제의 파이프라인에서 여러번 사용됩니다. 본 단계에서는 estimator를 선언할 때 전달되었습니다.
#
# +
from sagemaker.estimator import Estimator
model_path = f"s3://{default_bucket}/AbaloneTrain"
image_uri = sagemaker.image_uris.retrieve(
framework="xgboost",
region=region,
version="1.0-1",
py_version="py3",
# instance_type=training_instance_type,
)
xgb_train = Estimator(
image_uri=image_uri,
instance_type=training_instance_type,
instance_count=1,
output_path=model_path,
role=role,
)
xgb_train.set_hyperparameters(
objective="reg:linear",
num_round=50,
max_depth=5,
eta=0.2,
gamma=4,
min_child_weight=6,
subsample=0.7,
silent=0
)
# -
# 학습단계의 마지막으로 방금 정의한 estimator를 이용하여 `TrainingStep`을 생성합니다. `TrainingStep`의 입력데이터 채널을 정의할 때 `ProcessingStep`단계의 `properties`를 이용하여 값을 가져오고 있습니다. 해당 값은 파이프라인의 실행요청이 발생할 때 처리될 것입니다. 이 단계는 SageMaker 파이썬 SDK의 estimator에서 `fit`명령과 유사합니다.
#
# 파이프라인 설정시 `"train"` 출력 채널의 `S3Uri`를 이용하여 `TrainingStep`에 데이터를 지정하였습니다. 마찬가지로 `"test"`출력 채널의 값을 이용하여 모델 검증용 데이터를 지정하였습니다. 각 파이프라인 단계에서 `properties` 속성은 참조값으로 설정 후 실행단계에서 지정되며, 각각 파이썬 SDK상에서 대응되는 오브젝트의 describe호출의 응답의 속성과 동일합니다. 예를 들어 본 단계에서 `ProcessingStep`의 `properties` 속성은 [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html) API의 응답 결과와 동일합니다.
#
step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri
# +
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TrainingStep
step_train = TrainingStep(
name="AbaloneTrain",
estimator=xgb_train,
inputs={
"train": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri,
content_type="text/csv"
),
"validation": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"validation"
].S3Output.S3Uri,
content_type="text/csv"
)
},
)
# -
# 
# ### 학습모델을 평가하기 위한 모델 평가단계 정의
#
# 먼저 모델 평가용 프로세싱 단계에서 질행할 평가용 스크립트를 작성합니다.
#
# 파이프라인 실행 후 `evaluation.json`파일을 통해 평가결과를 확인할 수 있습니다.
#
# 평가 스크립트는 `xgboost`를 사용하고 다음을 실행합니다.
#
# * 모델을 로드합니다.
# * 테스트 데이터를 읽습니다.
# * 테스트 데이터에 대한 예측을 실행합니다.
# * 정확도, ROC곡선 등을 포함하는 분류보고서를 작성합니다.
# * 평가 디렉토리에 평가보고서를 저장합니다.
# +
# %%writefile abalone/evaluation.py
import json
import pathlib
import pickle
import tarfile
import joblib
import numpy as np
import pandas as pd
import xgboost
from sklearn.metrics import mean_squared_error
if __name__ == "__main__":
model_path = f"/opt/ml/processing/model/model.tar.gz"
with tarfile.open(model_path) as tar:
tar.extractall(path=".")
model = pickle.load(open("xgboost-model", "rb"))
test_path = "/opt/ml/processing/test/test.csv"
df = pd.read_csv(test_path, header=None)
y_test = df.iloc[:, 0].to_numpy()
df.drop(df.columns[0], axis=1, inplace=True)
X_test = xgboost.DMatrix(df.values)
predictions = model.predict(X_test)
mse = mean_squared_error(y_test, predictions)
std = np.std(y_test - predictions)
report_dict = {
"regression_metrics": {
"mse": {
"value": mse,
"standard_deviation": std
},
},
}
output_dir = "/opt/ml/processing/evaluation"
pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
evaluation_path = f"{output_dir}/evaluation.json"
with open(evaluation_path, "w") as f:
f.write(json.dumps(report_dict))
# -
# 다음으로, `ScriptProcessor` 프로세서의 인스턴스를 생성합니다. 이 인스턴스는 `ProcessingStep`에서 사용할 것입니다.
#
# 프로세서 정의시 `processing_instance_type` 파라미터를 이용하는 것을 확인합니다.
#
# +
from sagemaker.processing import ScriptProcessor
script_eval = ScriptProcessor(
image_uri=image_uri,
command=["python3"],
instance_type=processing_instance_type,
instance_count=1,
base_job_name="script-abalone-eval",
role=role,
)
# -
# 방금 생성한 processor 인스턴스를 이용하여 `ProcessingStep`을 생성합니다. 프로세싱의 입력 및 출력 채널과 파이프라인 실행시 호출될 스크립트 코드를 정의합니다. 이 단계는 SageMaker 파이썬 SDK에서 프로세싱 인스턴스의 `run`명령을 실행하는 것과 유사합니다.
#
# `step_train`의 `properties`속성 중 `S3ModelArtifacts`와 `step_process`의 `properties` 속성 중 `"test"` 출력 채널을 이용하여 프로세싱 단계의 입력을 정의하였습니다. `TrainingStep`과 `ProcessingStep`의 `properties` 속성은 각각 [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) API와 [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html) API의 응답 오브젝트와 동일합니다.
#
# +
from sagemaker.workflow.properties import PropertyFile
evaluation_report = PropertyFile(
name="EvaluationReport",
output_name="evaluation",
path="evaluation.json"
)
step_eval = ProcessingStep(
name="AbaloneEval",
processor=script_eval,
inputs=[
ProcessingInput(
source=step_train.properties.ModelArtifacts.S3ModelArtifacts,
destination="/opt/ml/processing/model"
),
ProcessingInput(
source=step_process.properties.ProcessingOutputConfig.Outputs[
"test"
].S3Output.S3Uri,
destination="/opt/ml/processing/test"
)
],
outputs=[
ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"),
],
code="abalone/evaluation.py",
property_files=[evaluation_report],
)
# -
# 
# ### 추론 실행에 사용할 모델 정의
#
# 모델을 사용하는 배치변환작업을 실행하기 위해 SageMaker Model을 생성합니다.
#
# 구체적으로, `TrainingStep` 인스턴스인 `step_train`의 속성 중 `S3ModelArtifacts` 정보를 활용하게 됩니다. `TrainingStep`의 `properties` 속성은 [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) API의 응답결과와 동일합니다.
#
# +
from sagemaker.model import Model
model = Model(
image_uri=image_uri,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
sagemaker_session=sagemaker_session,
role=role,
)
# -
# `instance_type`과 `accelerator_type`을 이용하여 Model input을 정의합니다. 이 값은 SageMaker 모델의 추론환경 배포를 위해 사용될 것입니다. 그 다음 앞서 정의한 model 인스턴스를 사용하여`CreateModelStep`을 생성합니다.
#
# +
from sagemaker.inputs import CreateModelInput
from sagemaker.workflow.steps import CreateModelStep
inputs = CreateModelInput(
instance_type="ml.m5.large",
accelerator_type="ml.eia1.medium",
)
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=model,
inputs=inputs,
)
# -
# ### 배치추론 실행을 위해 배치 변환단계 정의
#
# 이제 모델 인스턴스가 정의되었습니다. 다음으로 `Transformer`인스턴스를 정의합니다. 적절한 모델 타입과 실행할 인스턴스타입, 출력이 저장될 S3 URI를 지정합니다.
#
#
# 구체적으로는 `CreateModelStep`단계의 `step_create_model` 인스턴스의 속성 중 `ModelName`을 이용하여 모델명을 전달하였습니다. `CreateModelStep`의 `properties`속성은 [DescribeModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModel.html) API의 응답 오브젝트와 대응됩니다.
#
# +
from sagemaker.transformer import Transformer
transformer = Transformer(
model_name=step_create_model.properties.ModelName,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=f"s3://{default_bucket}/AbaloneTransform"
)
# -
# transformer 인스턴스와 이전에 정의한 `batch_data`파라미터를 사용하는 `TransformInput` 입력채널을 이용하여 배치변형 추론단계를 생성합니다.
# +
from sagemaker.inputs import TransformInput
from sagemaker.workflow.steps import TransformStep
step_transform = TransformStep(
name="AbaloneTransform",
transformer=transformer,
inputs=TransformInput(data=batch_data)
)
# -
# ### 모델 패키지 생성하고 모델 등록하기
#
# `RegisterModel`인스턴스를 생성하기 위해 학습단계에서 선언한 Estimator 인스턴스를 사용합니다. 모델 패키지는 재사용가능한 모델 아티팩트의 추상화이며 추론을 위해 필요한 모든 정보를 포함하고 있습니다. 예를 들어, 모델의 Weight가 있는 위치나 추론이미지 등의 설정이 이에 포함됩니다.
#
# 모델 패키지 그룹은 모델 패키지의 집합입니다. 특정 머신러닝 문제를 해결하기 위해 모델 패키지 그룹을 생성하고, 새로운 버전의 모델패키지를 추가할 수 있습니다. 일반적으로 SageMaker pipeline작업이 실행될 때 마다 새로운 버전의 모델패키지를 생성하고 모델패키지그룹에 추가하게 됩니다.
#
# `RegisterModel`은 Python SDK에서 Estimator 인스턴스의 `register` 메소드와 유사합니다.
#
# 구체적으로, `TrainingStep`으로 정의한 `step_train`에서 `S3ModelArtifacts`를 속성을 이용하여 모델을 전달합니다. `TrainingStep`의 `properties`에서 활용할 수 있는 속성들은 [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) 의 응답 오브젝트에 대응됩니다.
#
# 본 노트북에서 사용된 모델패키지 그룹이름은 SageMaker Project와 함께 모델 레지스트리와 CI/CD 작업에서 직접 활용될 수 있습니다.
#
# +
from sagemaker.model_metrics import MetricsSource, ModelMetrics
from sagemaker.workflow.step_collections import RegisterModel
model_metrics = ModelMetrics(
model_statistics=MetricsSource(
s3_uri="{}/evaluation.json".format(
step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"]
),
content_type="application/json"
)
)
step_register = RegisterModel(
name="AbaloneRegisterModel",
estimator=xgb_train,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
content_types=["text/csv"],
response_types=["text/csv"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name=model_package_group_name,
approval_status=model_approval_status,
model_metrics=model_metrics,
)
# -
# 
# ### 정확도를 체크하고 결과에 따라 모델 생성과 배치추론, 모델 등록을 실행하는 조건단계 정의하기
#
#
# 본 과정에서 `step_eval` 평가 단계의 평가 결과로 측정된 모델의 정확도가 특정 값을 넘어서는 경우에만 등록되도록 구성되었습니다. 파이프라인의 `ConditionStep`은 DAG에서 해당 단계의 속성 조건에 따라 조건부로 실행을 기능을 지원합니다.
#
# 이어지는 셀에서 실행하는 기능은 다음과 같습니다.
# * 평가 단계 `step_eval`의 출력 정확도에 대하여 `ConditionLessThanOrEqualTo` 조건 설정
# * 생성한 조건을 `ConditionStep`에서 분기를 위한 조건속성으로 설정
# * `ConditionStep`의 `if_steps`을 이용하여 조건값이 `True`일 경우에만 `CreateModelStep`, `TransformStep`, `RegisterModel` 단계가 진행되도록 설정
#
# +
from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import (
ConditionStep,
JsonGet,
)
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step=step_eval,
property_file=evaluation_report,
json_path="regression_metrics.mse.value",
),
right=6.0
)
step_cond = ConditionStep(
name="AbaloneMSECond",
conditions=[cond_lte],
if_steps=[step_register, step_create_model, step_transform],
else_steps=[],
)
# -
# 
# ### 파리마터, 단계, 조건을 조합하여 최종 파이프라인 정의
#
# 이제 지금까지 생성한 단계들을 하나의 파이프라인으로 조합하고 실행하도록 하겠습니다.
#
# 파이프라인은 `name`, `parameters`, `steps` 속성이 필요합니다. 여기서 파이프라인의 이름은 `(account, region)` 조합에 대하여 유일(unique))해야 합니다.
#
# 주의:
#
# * 정의에 사용한 모든 파라미터가 존재해야 합니다. All of the parameters used in the definitions must be present.
# * 파이프라인으로 전달된 단계(step)들은 실행순서와는 무관합니다. SageMaker Pipeline은 단계가 실행되고 완료될 수 있도록 의존관계를를 해석합니다.
# * 단계들은 반드시 파이프라인내 단계 리스트와 컨디션의 if/esle 조건에서 유일해야 합니다.
#
# +
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_type,
processing_instance_count,
training_instance_type,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
# -
# 
# #### (선택) 파이프라인 정의 확인
#
# 파이프라인을 정의하는 JSON을 생성하고 파이프라인 내에서 사용하는 파라미터와 단계별 속성들이 잘 정의되었는지 확인할 수 있습니다.
# +
import json
definition = json.loads(pipeline.definition())
definition
# -
# ### 파이프라인을 SageMaker에 제출하고 실행하기
#
# 파이프라인 정의를 파이프라인 서비스에 제출합니다. 함께 전달되는 역할(role)을 이용하여 AWS에서 파이프라인을 생성하고 작업의 각 단계를 실행할 것입니다.
pipeline.upsert(role_arn=role)
# 디폴트값을 이용하여 파이프라인을 샐행합니다.
execution = pipeline.start()
# ### 파이프라인 운영: 파이프라인 대기 및 실행상태 확인
#
# 워크플로우의 실행상황을 살펴봅니다.
execution.describe()
# 실행이 완료될 때까지 기다립니다.
# +
# execution.wait()
# -
# 실행된 단계들을 리스트업합니다. 파이프라인의 단계실행 서비스에 의해 시작되거나 완료된 단계를 보여줍니다.
execution.list_steps()
# ### 평가결과 확인
#
# 파이프라인의 실행이 완료된 후 생성된 결과 모델의 평가결과를 확인합니다. `evaluation.json`파일을 S3로부터 다운로드하고 내용을 살펴봅니다.
# +
from pprint import pprint
evaluation_json = sagemaker.s3.S3Downloader.read_file("{}/evaluation.json".format(
step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"]
))
pprint(json.loads(evaluation_json))
# -
# ### 계보(Lineage)
#
# 파이프라인에 의해 생성된 아티팩트의 계보를 살펴봅니다.
# +
import time
from sagemaker.lineage.visualizer import LineageTableVisualizer
viz = LineageTableVisualizer(sagemaker.session.Session())
for execution_step in reversed(execution.list_steps()):
print(execution_step)
display(viz.show(pipeline_execution_step=execution_step))
time.sleep(5)
# -
# ### 파라미터기반 실행
#
# 생성한 파이프라인을 다른 파라미터값을 이용하여 다시 실행할 수 있습니다. 파라미터정보는 딕셔너리 형태로 파라미터이름과 값을 지정하여 전달하면 디폴트값을 오버라이드하게 됩니다.
#
# 모델의 성능에 따라 이번에는 컴퓨팅최적화된 인스턴스 타입을 이용하여 파이프라인을 실행하고 승인 상태를 자동으로 "Approved"로 설정하고 싶다면 다음 셀의 코드를 실행할 수 있습니다. 모델의 승인상태가 "Approved"라는 의미는 `RegisterModel` 단계에서 패키지버전이 등록될 때 자동으로 CI/CD 파이프라인에 의해 배포가능한 상태가 된다는 것을 의미합니다. 이후 배포파이프라인 프로세스는 SageMaker project를 통하여 자동화할 수 있습니다.
#
execution = pipeline.start(
parameters=dict(
ProcessingInstanceType="ml.c5.xlarge",
ModelApprovalStatus="Approved",
)
)
# +
# execution.wait()
# -
execution.list_steps()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Reverse dictionary
#
# Given the following `dict` `d` compute the reverse dictionary `rd`. Let `k_d` and `v_d` be the keys and values of `d`, respectively. The keys of `rd` `k_rd` are all the integer numbers contained in all the `v_d`. The values of `rd` are lists containing all the keys `k_d` where `k_rd` is inside the corresponding `v_d`. For example
# ```python
# d = {"a": [1, 2, 3], "b": [45, 6], "c": [2, 45]}
#
# rd = {1: ["a"], 2: ["a", "c"], 3: ["a"], 6: ["b"], 45: ["b", "c"]}
# ```
#
# If you do not write the proper code, the computational time might exceed the time given for the exam! Numpy is not required.
#
# Hints:
# - comprehensions are your friend.
# - work on a small dictionay, once you are satisfied with your code, apply it to the big `d`
# - you can use the `test_exam.py` to test your implementation running `pytest test_exam.py`
# +
chars = "qwertyuiopasdfghjklzxcvbnm"
chars = sorted(chars.upper() + chars)
keys = [c + str(n) for c in chars for n in range(100)]
import random
random.seed(42)
d = {k: [random.randint(1, 200) for _ in range(random.randint(1, 10))] for k in keys}
for i, (k, v) in enumerate(d.items()):
print(k, ":", v)
if i == 10:
break
# +
def reverse_dict(d):
'''
Compute the reverse dictionary from a given dictionary
Parameters
----------
d: dictionary
The dictionary from which compute its reverse.
Returns
-------
dictionary
The reverse dictionary computed from a dictionary given as input.
'''
new_keys = set([item for sublist in list(d.values()) for item in sublist])
return {k: [item[0] for item in list(d.items()) if item[1].count(k) >= 1] for k in new_keys}
rd = reverse_dict(d)
for i, (k, v) in enumerate(rd.items()):
print(k, ":", v)
if i == 10:
break
# -
# !pytest test_exam.py
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Implementing Neural Network from Scratch.
# Neural Networks are really powerful algorithms used for classification. <br>
# Dataset = Iris_Dataset <br>
# Link = http://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html <br>
#
# ### Import required libraries
from sklearn import datasets #for dataset
import numpy as np #for maths
import matplotlib.pyplot as plt #for plotting
# ### Get Dataset
# +
iris = datasets.load_iris() #load the dataset
data = iris.data #get features
target = iris.target #get labels
shape = data.shape #shape of data
#convert into numpy array
data = np.array(data).reshape(shape[0],shape[1])
target = np.array(target).reshape(shape[0],1)
#print shape
print("Data Shape = {}".format(data.shape))
print("Target Shape = {}".format(target.shape))
print('Classes : {}'.format(np.unique(target)))
print('Sample data : {} , Target = {}'.format(data[70],target[70]))
# -
# ### Define Parameters and Hyperparameters
#
#
#
#
#
# One hidden layer Neural Network.
# 
# Input Units = 4 <br>
# Hidden Units = 8 <br>
# Output Units = 3 <br>
# +
#HYPERPARAMETERS
#num of target labels
num_classes = len(np.unique(target))
#define layer_neurons
input_units = 4 #neurons in input layer
hidden_units = 8 #neurons in hidden layer
output_units = 3 #neurons in output layer
#define hyper-parameters
learning_rate = 0.03
#regularization parameter
beta = 0.00001
#num of iterations
iters = 4001
# -
# ### Dimesions of Parameters
# Shape of layer1_weights (Wxh) = (4,8) <br>
# Shape of layer1_biasess (Bh) = (8,1) <br>
# Shape of layer2_weights (Why) = (8,3) <br>
# Shape of layer2_biasess (By) = (3,1) <br>
# +
#PARAMETERS
#initialize parameters i.e weights
def initialize_parameters():
#initial values should have zero mean and 0.1 standard deviation
mean = 0 #mean of parameters
std = 0.03 #standard deviation
layer1_weights = np.random.normal(mean,std,(input_units,hidden_units))
layer1_biases = np.ones((hidden_units,1))
layer2_weights = np.random.normal(mean,std,(hidden_units,output_units))
layer2_biases = np.ones((output_units,1))
parameters = dict()
parameters['layer1_weights'] = layer1_weights
parameters['layer1_biases'] = layer1_biases
parameters['layer2_weights'] = layer2_weights
parameters['layer2_biases'] = layer2_biases
return parameters
# -
# ### Activation Function
#
# **Sigmoid**
#
# 
#
# +
#activation function
def sigmoid(X):
return 1/(1+np.exp((-1)*X))
#softmax function for output
def softmax(X):
exp_X = np.exp(X)
exp_X_sum = np.sum(exp_X,axis=1).reshape(-1,1)
exp_X = (exp_X/exp_X_sum)
return exp_X
# -
# ### Define Utility Functions
# #### 1. Forward Propagation
# ---- Logits = matmul(X,Wxh) + Bh <br>
# ---- A = sigmoid(logits) <br>
# ---- logits = matmul(A,Why) + By <br>
# ---- output = softmax(logits) <br>
#
# Store output and A in cache to use it in backward propagation <br>
#
# #### 2. Backward Propagation
# ---- Error_output = output - train_labels <br>
# ---- Error_activation = (matmul(error_output,Why.T))(A)(1-A) <br>
# ---- dWhy = (matmul(A.T,error_output))/m <br>
# ---- dWxh = (matmul(train_dataset.T,error_activation))/m <br>
#
# m = len(train_dataset) <br>
# Store derivatives in derivatives dict
#
# #### 3. Update Parameters
# ---- Wxh = Wxh - learning_rate(dWxh + beta*Wxh) <br>
# ---- Why = Why - learning_rate(dWhy + beta*Why) <br>
#
# #### 4. Calculate Loss and Accuracy
# ---- Loss = (-1(Y log(prediction)) + (1-Y) (log(1-predictions))) + beta * (sum(Wxh^2) + sum(Why^2)))/m <br>
# ---- Accuracy = sum(Y==predictions)/m
# +
#forward propagation
def forward_propagation(train_dataset,parameters):
cache = dict() #to store the intermediate values for backward propagation
m = len(train_dataset) #number of training examples
#get the parameters
layer1_weights = parameters['layer1_weights']
layer1_biases = parameters['layer1_biases']
layer2_weights = parameters['layer2_weights']
layer2_biases = parameters['layer2_biases']
#forward prop
logits = np.matmul(train_dataset,layer1_weights) + layer1_biases.T
activation1 = np.array(sigmoid(logits)).reshape(m,hidden_units)
activation2 = np.array(np.matmul(activation1,layer2_weights) + layer2_biases.T).reshape(m,output_units)
output = np.array(softmax(activation2)).reshape(m,num_classes)
#fill in the cache
cache['output'] = output
cache['activation1'] = activation1
return cache,output
#backward propagation
def backward_propagation(train_dataset,train_labels,parameters,cache):
derivatives = dict() #to store the derivatives
#get stuff from cache
output = cache['output']
activation1 = cache['activation1']
#get parameters
layer1_weights = parameters['layer1_weights']
layer2_weights = parameters['layer2_weights']
#calculate errors
error_output = output - train_labels
error_activation1 = np.matmul(error_output,layer2_weights.T)
error_activation1 = np.multiply(error_activation1,activation1)
error_activation1 = np.multiply(error_activation1,1-activation1)
#calculate partial derivatives
partial_derivatives2 = np.matmul(activation1.T,error_output)/len(train_dataset)
partial_derivatives1 = np.matmul(train_dataset.T,error_activation1)/len(train_dataset)
#store the derivatives
derivatives['partial_derivatives1'] = partial_derivatives1
derivatives['partial_derivatives2'] = partial_derivatives2
return derivatives
#update the parameters
def update_parameters(derivatives,parameters):
#get the parameters
layer1_weights = parameters['layer1_weights']
layer2_weights = parameters['layer2_weights']
#get the derivatives
partial_derivatives1 = derivatives['partial_derivatives1']
partial_derivatives2 = derivatives['partial_derivatives2']
#update the derivatives
layer1_weights -= (learning_rate*(partial_derivatives1 + beta*layer1_weights))
layer2_weights -= (learning_rate*(partial_derivatives2 + beta*layer2_weights))
#update the dict
parameters['layer1_weights'] = layer1_weights
parameters['layer2_weights'] = layer2_weights
return parameters
#calculate the loss and accuracy
def cal_loss_accuray(train_labels,predictions,parameters):
#get the parameters
layer1_weights = parameters['layer1_weights']
layer2_weights = parameters['layer2_weights']
#cal loss and accuracy
loss = -1*np.sum(np.multiply(np.log(predictions),train_labels) + np.multiply(np.log(1-predictions),(1-train_labels)))/len(train_labels) + np.sum(layer1_weights**2)*beta/len(train_labels) + np.sum(layer2_weights**2)*beta/len(train_labels)
accuracy = np.sum(np.argmax(train_labels,axis=1)==np.argmax(predictions,axis=1))
accuracy /= len(train_dataset)
return loss,accuracy
# -
# ### Train Function
#
# 1. Initialize Parameters
# 2. Forward Propagation
# 3. Backward Propagation
# 4. Calculate Loss and Accuracy
# 5. Update the parameters
#
# Repeat the steps 2-5 for the given number of iterations
# +
#Implementation of 3 layer Neural Network
#training function
def train(train_dataset,train_labels,iters=2):
#To store loss after every iteration.
J = []
#WEIGHTS
global layer1_weights
global layer1_biases
global layer2_weights
global layer2_biases
#initialize the parameters
parameters = initialize_parameters()
layer1_weights = parameters['layer1_weights']
layer1_biases = parameters['layer1_biases']
layer2_weights = parameters['layer2_weights']
layer2_biases = parameters['layer2_biases']
#to store final predictons after training
final_output = []
for j in range(iters):
#forward propagation
cache,output = forward_propagation(train_dataset,parameters)
#backward propagation
derivatives = backward_propagation(train_dataset,train_labels,parameters,cache)
#calculate the loss and accuracy
loss,accuracy = cal_loss_accuray(train_labels,output,parameters)
#update the parameters
parameters = update_parameters(derivatives,parameters)
#append loss
J.append(loss)
#update final output
final_output = output
#print accuracy and loss
if(j%500==0):
print("Step %d"%j)
print("Loss %f"%loss)
print("Accuracy %f%%"%(accuracy*100))
return J,final_output
# +
#shuffle the dataset
z = list(zip(data,target))
np.random.shuffle(z)
data,target = zip(*z)
#make train_dataset and train_labels
train_dataset = np.array(data).reshape(-1,4)
train_labels = np.zeros([train_dataset.shape[0],num_classes])
#one-hot encoding
for i,label in enumerate(target):
train_labels[i,label] = 1
#normalizations
for i in range(input_units):
mean = train_dataset[:,i].mean()
std = train_dataset[:,i].std()
train_dataset[:,i] = (train_dataset[:,i]-mean)/std
# -
#train data
J,final_output = train(train_dataset,train_labels,iters=4001)
# #### Reached an Accuracy of 97%
# ### Plot the loss vs iteration graph
#plot loss graph
plt.plot(list(range(1,len(J))),J[1:])
plt.xlabel('Iterations')
plt.ylabel('Loss')
plt.title('Iterations VS Loss')
plt.show()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
sc
spark.read.format("csv")
csvFile = spark.read.format("csv")\
.option("header", "true")\
.option("mode", "FAILFAST")\
.option("inferSchema", "true")\
.load("./data/flight-data/csv/2010-summary.csv")
csvFile.write.format("csv").mode("overwrite").option("sep", "\t").save("./tmp/my-tsv-file.tsv")
# +
# json
spark.read.format("json")
# -
spark.read.format("json").option("mode", "FAILFAST")\
.option("inferSchema", "true")\
.load("./data/flight-data/json/2010-summary.json").show(5)
csvFile.write.format("json").mode("overwrite").save("./tmp/my-json-file.json")
# +
# 파케이 파일
spark.read.format("parquet")
# -
spark.read.format("parquet")\
.load("./data/flight-data/parquet/2010-summary.parquet").show(5)
csvFile.write.format("parquet").mode("overwrite").save("./tmp/my-parquet-file.parquet")
spark.read.format("orc").load("./data/flight-data/orc/2010-summary.orc").show(5)
csvFile.write.format("orc").mode("overwrite").save("./tmp/my-orc-file.orc")
# +
# SQL
driver = "org.sqlite.JDBC"
path = "./data/flight-data/jdbc/my-sqlite.db"
url = "jdbc:sqlite:" + path
tablename = "flight_info"
# +
# 접속 테스트
import java.sql.DriverManager
val connection = DriverManager.getConnection(url)
connection.isClosed()
connection.close()
# -
dbDataFrame = spark.read.format("jdbc").option("url", url)\
.option("dbtable", tablename).option("driver", driver).load()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [Root]
# language: python
# name: Python [Root]
# ---
# +
###############################################
#Original author: Dan Liu
#Last modified by: Dan Liu
#Last modified time: 11/16/2016
#Give a visualized map showing multiple widgets that filter job posting distribution over US.
#get_geo_world() function given is referenced from webpage https://groups.google.com/a/continuum.io/forum/#!topic/bokeh/cJ7tzsm1aLc
#This notebook reads data stored in data science experience project
###############################################
# To run this code, need following packages
# pip install bokeh
# sudo pip install bokeh --upgrade
# python
#>>> import bokeh.sampledata
#>>> bokeh.sampledata.download()
from bokeh.io import output_notebook, push_notebook, show
from bokeh.models import (
ColumnDataSource,
HoverTool,
ColorBar, LinearColorMapper, FixedTicker, NumeralTickFormatter, BasicTicker,
Callback, Select, CustomJS,
LabelSet, TapTool
)
from bokeh.models.layouts import VBox,HBox
from bokeh.palettes import Blues9 as palette
from bokeh.plotting import figure, gridplot
from bokeh.layouts import widgetbox
from bokeh.sampledata.us_states import data as states_map
import csv
import numpy as np
import requests
from io import BytesIO
import json
import pandas as pd
###############################################
#give the coordinates of the world via json url
#original world-geo json file given by Johan Sundström https://github.com/johan/world.geo.json
#url above provided by Dennis O'Brien and following codes come from Jean Felder
# on Google Groups 'Bokeh User mailing list' https://groups.google.com/a/continuum.io/forum/#!topic/bokeh/cJ7tzsm1aLc
#thanks to their extraodinary work!
#parmas:
# @features: dicts of country name and polygon boundaries geo location
# read from world-geo json url
#return:
# ColumnDataSource object to plot
###############################################
def get_geo_world():
url = 'https://raw.githubusercontent.com/johan/world.geo.json/master/countries.geo.json'
r = requests.get(url)
geo_json_data = r.json()
features = geo_json_data['features']
depth = lambda L: isinstance(L, list) and max(map(depth, L))+1
xs = []
ys = []
names = []
for feature in features:
name = feature['properties']['name']
coords = feature['geometry']['coordinates']
nbdims = depth(coords)
# one border
if nbdims == 3:
pts = np.array(coords[0], 'f')
xs.append(pts[:, 0])
ys.append(pts[:, 1])
names.append(name)
# several borders
else:
for shape in coords:
pts = np.array(shape[0], 'f')
xs.append(pts[:, 0])
ys.append(pts[:, 1])
names.append(name)
source = ColumnDataSource(data=dict(x = xs, y = ys, name = names,))
return source
# -
df_data_1 = pd.read_csv('Count-allOccupations-Continent.csv')
df_data_1.head()
# +
###############################################
#give the count data of us each state according to selector
#params:
# @occupation_set: a list of occupation id that user want, default as in each state add all count together
#return:
# an dict of count data, contains key of 'State' and numeric number of occupation id
###############################################
def get_count_us_continent(occupations_set):#, add_all = None):
data = pd.read_csv('Count-allOccupations-Continent.csv')
headers = data.columns.values
state_count_dict = {}
state_count_dict[headers[0]] = []
for i in range(1,len(headers)):
headers[i] = int(headers[i])
state_count_dict[headers[i]] = []
for row in data.iterrows():
row = row[1]
# the first item of each row is an instance of 'State', not an int
state_count_dict[headers[0]].append(row[0])
for h, v in zip(headers[1:], row[1:]):
state_count_dict[h].append(int(v))
state_count = np.zeros(len(state_count_dict['State']))
#if not add_all:
# add all occupations' count data together
# keys = [key for key in state_count_dict.keys() if key != 'State']
# for i in keys:
# state_count = [sum(x) for x in zip(state_count, state_count_dict[i])]
#else:
# add only required count data from occupations_set
for i in occupations_set:
state_count = [sum(x) for x in zip(state_count, state_count_dict[i])]
return state_count
# +
###############################################
#give the coordinates and count data of us states
#params:
# @state_count_experience_selector_dict: dict of different count data on each state according to selection,
# here state are already sorted alphabetically in .csv file.
# @state_count_careerarea_selector_dict: dict of count data on each state according to doubel selection
# @state_map: sampledata from bokeh moduls, multipolygon of us map data
#return:
# ColumnDataSource object to plot
###############################################
def get_source_geo_and_count_us_continent(state_count_experience_selector_dict, state_count_careerarea_selector_dict, states_map):
states = {code: state for code, state in states_map.items()}
states_sort_by_name = states.values()
states_sort_by_name = sorted(states_sort_by_name, key = lambda x : x['name'])
# sort states' geo by its name, it helps decide the order of count data. cause .csv data is already sorted by state name
state_xs = [state["lons"] for state in states_sort_by_name]
state_ys = [state["lats"] for state in states_sort_by_name]
state_names = [state["name"] for state in states_sort_by_name]
source = ColumnDataSource(data=dict(x = state_xs, y = state_ys,
name = [name + ", United States" for name in state_names]))
state_count_total = np.zeros(len(list(state_count_experience_selector_dict.values())[0]))
for name, state_count in state_count_experience_selector_dict.items():
state_count_total = [sum(x) for x in zip(state_count_total, state_count)]
source.add(data = state_count, name = 'count'+name)
source.add(data = state_count_total, name = 'count_all')
source.add(data = state_count_total, name = 'count')
for experience_selector_name, state_count_careerarea in state_count_careerarea_selector_dict.items():
careerarea_selector_name_initial = 'count'+experience_selector_name
for careerarea_name, state_count in state_count_careerarea.items():
source.add(data = state_count, name = careerarea_selector_name_initial + careerarea_name)
return source
# -
###############################################
#gives a colormapping method and colorbar (not use it any more)
#params:
# @palette: from bokeh library
# @quantile_level: the amount of quantile levels that user want to plot the data
# @data: data that needs to be plotted with different levels of quantile
#return:
# ColorMapper object and list of int as ticker
###############################################
def color_map_ticker(palette, quantile_level, data):
p = palette[:quantile_level - len(palette)]
p.reverse()
colormap = LinearColorMapper(palette=p, low=min(data), high=max(data))
fixedticker = [min(data) + 1 + (max(data) - min(data) - 1) * i / quantile_level#, i/(quantile_level)*100)
for i in range(0,quantile_level+1) ]
#colormap, legendmap = [],[]
#for c in state_count:
# index = 0
# while(c > quantile[index] and index < len(quantile)):
# index += 1
# colormap.append(palette[index-1])
return colormap, fixedticker
df_data_2 = pd.read_csv('Occupationid_firststep_group_careerarea.csv')
df_data_2.head()
###############################################
#gives info of every occupation id via .csv file
#return:
# dicts: firststep, starterjob, occupationgroup, careerarea that maps to a set of occupation ids.
# dicts: group_name maps group id to its name, careerarea_name maps careerarea id to its name
###############################################
def get_occupation_info():
data = pd.read_csv('Occupationid_firststep_group_careerarea.csv')
occupations_firststep = {"False": [], "True": []}
occupations_starterjob = {"False": [], "True": []}
occupations_careerarea = {}
occupations_occupationgroup = {}
group_name = {}
careerarea_name = {}
for row in data.iterrows():
row = row[1]
Id = int(row[0])
if row[1] == False:
occupations_firststep["False"].append(Id)
else:
occupations_firststep["True"].append(Id)
if row[2] == False:
occupations_starterjob["False"].append(Id)
else:
occupations_starterjob["True"].append(Id)
group_id = int(row[3])
group_name[group_id] = row[4]
if group_id in occupations_occupationgroup.keys():
occupations_occupationgroup[group_id].append(Id)
else:
occupations_occupationgroup[group_id] = []
occupations_occupationgroup[group_id].append(Id)
careerarea_id = int(row[5])
careerarea_name[careerarea_id] = row[6]
if careerarea_id in occupations_careerarea.keys():
occupations_careerarea[careerarea_id].append(Id)
else:
occupations_careerarea[careerarea_id] = []
occupations_careerarea[careerarea_id].append(Id)
return (occupations_firststep,
occupations_starterjob,
occupations_occupationgroup,
occupations_careerarea,
group_name,
careerarea_name)
###############################################
#give the coordinates and count data of us states
#params:
# @sset_2_year, set_1_year, set_none: sets of occupation id from experience selection
# @careerarea: career data maps area id to sets of occupation id
# @careerarea_name: career data maps area name to its name
#return:
# - dict of careerarea total count in all states according to 3 experience selectors (used for bar plot)
# - dict of careerarea count in each state according to 3 experience selectors (used for career selector)
###############################################
def get_careerarea_count_selector(set_2_year, set_1_year, set_none, careerarea, careerarea_name):
careerarea_count_total_2_year = {}
careerarea_count_total_1_year = {}
careerarea_count_total_none = {}
careerarea_count_all = {}
careerarea_count_2_year = {}
careerarea_count_1_year = {}
careerarea_count_none = {}
for k,v in careerarea.items():
temp_career_set_2_year = set(v)&set(set_2_year)
temp_career_set_1_year = set(v)&set(set_1_year)
temp_career_set_none = set(v)&set(set_none)
temp_count_all = get_count_us_continent(v)
temp_count_2_year = get_count_us_continent(temp_career_set_2_year)
temp_count_1_year = get_count_us_continent(temp_career_set_1_year)
temp_count_none = get_count_us_continent(temp_career_set_none)
temp_sum_2_year = sum(temp_count_2_year)
temp_sum_1_year = sum(temp_count_1_year)
temp_sum_none = sum(temp_count_none)
name = careerarea_name[k]
careerarea_count_total_2_year[name] = temp_sum_2_year
careerarea_count_total_1_year[name] = temp_sum_1_year
careerarea_count_total_none[name] = temp_sum_none
careerarea_count_all[name] = temp_count_all
careerarea_count_2_year[name] = temp_count_2_year
careerarea_count_1_year[name] = temp_count_1_year
careerarea_count_none[name] = temp_count_none
careerarea_count_total_dict = dict(
_2_year = careerarea_count_total_2_year,
_1_year = careerarea_count_total_1_year,
_none = careerarea_count_total_none)
state_count_careerarea_selector_dict = dict(
_all_ = careerarea_count_all,
_2_year_ = careerarea_count_2_year,
_1_year_ = careerarea_count_1_year,
_none_ = careerarea_count_none)
return careerarea_count_total_dict, state_count_careerarea_selector_dict
###############################################
#give the coordinates and count data of us states
#params:
# @careerarea_count_dict: dict of careerarea count according to 3 selectors
#return:
# ColumnDataSource object to plot
###############################################
def get_source_careerarea_experience_count(careerarea_count_total_dict):
experience_selector = ['count_all']
experience_selector.extend(np.zeros(22))
color = ['#6baed6'] * 23
career_source = ColumnDataSource(data=dict(
y = range(1,23+1),
label_x = np.zeros(23),
experience_selector = experience_selector,
color = color,
color2 = color,
))
careerarea_count_all = {}
for name, careerarea_count in careerarea_count_total_dict.items():
x_temp = []
tag_temp = []
width_temp = []
for k,v in sorted(careerarea_count.items(), key = lambda x: x[1]):
x_temp.append(v/2)
tag_temp.append(k)
width_temp.append(v)
if k in careerarea_count_all.keys():
careerarea_count_all[k]+=v
else:
careerarea_count_all[k]=v
career_source.add(data = width_temp, name = 'width'+name)
career_source.add(data = x_temp, name = 'x'+name)
career_source.add(data = tag_temp, name = 'tag'+name)
width = sorted(careerarea_count_all.values())
x = [v/2 for v in sorted(careerarea_count_all.values())]
tag = [k for k,v in sorted(careerarea_count_all.items(), key = lambda x: x[1])]
career_source.add(data = width, name = 'width')
career_source.add(data = width, name = 'width_all')
career_source.add(data = x, name = 'x')
career_source.add(data = x, name = 'x_all')
career_source.add(data = tag, name = 'tag')
career_source.add(data = tag, name = 'tag_all')
return career_source
# +
###############################################
#print map with all countries in the world and give them a country name hovertool
###############################################
palette1 = ['#6baed6', '#4292c6', '#2171b5', '#08519c', '#08306b']
TOOLS = "pan,wheel_zoom,box_zoom,reset,save"
mp = figure(
title="Job posting distribution over US",
tools=TOOLS, toolbar_location="above",
x_axis_location=None, y_axis_location=None,
plot_width=1050, plot_height=680, x_range=(-160,-55), y_range=(7,75)
)
mp.grid.grid_line_color = None
mp.title.text_font_size = '20pt'
#print world map as background
mp1 = mp.patches(
'x', 'y', source=get_geo_world(),
fill_color="#F1EEF6", fill_alpha=0.7, line_width=0.5)
mp.add_tools(HoverTool(renderers=[mp1],
point_policy = "follow_mouse",
tooltips = {
"Name": "@name",
"(Lon, Lat)":
"($x, $y)",}))
# +
############################################
#get the new set of occupations according to selection
############################################
firststep, starterjob, occupationgroup, careerarea, group_name, careerarea_name = get_occupation_info()
#get the sets of occupations under different experience selectors
set_2_year = firststep['True']
set_1_year = set(firststep['False'])&set(starterjob['True'])
set_none = set(firststep['False'])&set(starterjob['False'])
#get the dicts of total count and count in each state of each career area under experience selectors
careerarea_count_total_dict, state_count_careerarea_selector_dict = get_careerarea_count_selector(set_2_year,set_1_year,set_none,careerarea,careerarea_name)
#print the career area count bar
career_source = get_source_careerarea_experience_count(careerarea_count_total_dict)
career_area_bar = figure(title="Select career areas",x_axis_location=None, y_axis_location = None,width=290, height=642, tools = "reset", toolbar_location="above", x_range = (0, max(career_source.data['width'])))
career_area_bar.grid.grid_line_color = None
career_area_bar.title.text_font_style = 'normal'
bar = career_area_bar.rect(x='x', y='y',width='width',height=0.4, color = 'color',source = career_source)
career_labels = LabelSet(x="label_x", y="y",text="tag",y_offset=5, x_offset = 2,text_font_size="8pt", text_color="#555555",source=career_source, text_align='left')
career_area_bar.add_layout(career_labels)
career_area_bar.add_tools(HoverTool(renderers=[bar],point_policy = "follow_mouse",tooltips = {"career area": "@tag","total count": "@width"}))
# +
############################################
#print the map that relates to two selectors
############################################
#get the count in each state of each experience selector
count_2_year = get_count_us_continent(set_2_year)
count_1_year = get_count_us_continent(set_1_year)
count_none = get_count_us_continent(set_none)
#make these count data into a dict
state_count_experience_selector_dict = dict(
_none = count_none,
_1_year = count_1_year,
_2_year = count_2_year)
#get the source data based on experience selector and careerarea selector
source = get_source_geo_and_count_us_continent(
state_count_experience_selector_dict,
state_count_careerarea_selector_dict,
states_map)
###
#here I have a bug that the color bar text of map cannot change according to selectors' changing.
#It is mainly because the argument of colobar model in bokeh does not support specific source data
#my way of solving this bug is to show the percent instead of specific numbers
###
#color_mapper, fixed_ticks = color_map_ticker(palette, 5, source.data['count'])
mp2 = mp.patches('x', 'y', source=source,
fill_color={'field': 'count', 'transform': LinearColorMapper(palette=palette1)},
fill_alpha=0.7, line_color="grey", line_width=0.5)
#color_bar = ColorBar(color_mapper=color_mapper, ticker=FixedTicker(ticks = fixed_ticks),
# formatter = NumeralTickFormatter(format="0.0"), label_standoff=14, border_line_color=None, location=(0,0))
color_bar = ColorBar(
color_mapper = LinearColorMapper(palette=palette1,
low = 0,#min(source.data['count']),
high = 1),#max(source.data['count'])),
ticker=FixedTicker(ticks=[0,0.2,0.4,0.6,0.8,1]),#BasicTicker(),
formatter = NumeralTickFormatter(format="0.0%"),
label_standoff=14, border_line_color=None, location=(0,0))
#print(color_bar)
mp.add_layout(color_bar, 'right')
mp.add_tools(HoverTool(renderers=[mp2],
point_policy = "follow_mouse",
tooltips = {
"Name": "@name",
"Job posting amount": "@count",
"(Lon, Lat)": "($x, $y)",}))
# +
###############################################
#callbacks
###############################################
callback_experience = CustomJS(args=dict(
source1 = source,
source2 = career_source,
color_bar = color_bar),
code="""
var f = cb_obj.get('value');
var data1 = source1.get('data');
var count = data1['count'];
var mapper = color_bar.get('color_mapper');
var mapper_low = mapper.get('low');
var mapper_high = mapper.get('high');
var data2 = source2.get('data');
var width = data2['width'];
var x = data2['x'];
var tag = data2['tag'];
var experience_selector = data2['experience_selector'][0]
if (f == 'None') {
for (i = 0; i < count.length; i++) {
count[i] = data1['count_none'][i];
}
for (j = 0; j < width.length; j++){
wjdth[i] = data2['width_none'][j];
x[j] = data2['x_none'][j];
tag[j] = data2['tag_none'][j];
}
experience_selector = "count_none"
}else if (f == 'At least 1 year') {
for (i = 0; i < count.length; i++) {
count[i] = data1['count_1_year'][i];
}
for (j = 0; j < width.length; j++){
width[j] = data2['width_1_year'][j];
x[j] = data2['x_1_year'][j];
tag[j] = data2['tag_1_year'][j];
}
experience_selector = "count_1_year"
}else if (f == 'At least 2 year'){
for (i = 0; i < count.length; i++) {
count[i] = data1['count_2_year'][i];
}
for (j = 0; j < width.length; j++){
width[j] = data2['width_2_year'][j];
x[j] = data2['x_2_year'][j];
tag[j] = data2['tag_2_year'][j];
}
experience_selector = "count_2_year"
}else{
for (i = 0; i < count.length; i++) {
count[i] = data1['count_all'][i];
}
for (j = 0; j < width.length; j++){
width[j] = data2['width_all'][j];
x[j] = data2['x_all'][j];
tag[j] = data2['tag_all'][j];
}
experience_selector = "count_all"
}
mapper_low = Math.min(count);
mapper_high = Math.max(count);
source1.trigger('change');
source2.trgger('change');
bar.trigger('change');
""")
callback_career = CustomJS(args=dict(
source1 = source,
source2 = career_source),
code="""
var inds = cb_obj.get('selected')['1d'].indices;
var data1 = source1.get('data');
var count = data1['count'];
var data2 = source2.get('data');
var tag = data2['tag'];
var experience_selector_name = data2['experience_selector'][0];
var color = data2['color'];
num = 0
for (i = 0; i<color.length; i++){
if(color[i] == "#08519c"){num += 1;}
}
for (i = 0; i < inds.length; i++) {
careerarea_selector_name = experience_selector_name + "_"+ tag[inds[i]];
if (color[inds[i]] == "#08519c"){
color[inds[i]] = data2['color2'][inds[i]];
for(j = 0; j < count.length; j++){
if (num == 0){
temp = data1[experience_selector_name][j];
}else{
temp = count[j];
}
temp = temp - data1[careerarea_selector_name][j];
if(temp <= 0){
count[j] = data1[experience_selector_name][j];
}else{
count[j] = temp
}
}
}
else{
color[inds[i]] = "#08519c";
for(j = 0; j < count.length; j++){
if (num == 0){
temp = 0;
}else{
temp = count[j];
}
count[j] = temp + data1[careerarea_selector_name][j];
}
}
}
source1.trigger('change');
source2.trigger('change');
""")
######################################################
#Deploy widget, call back
######################################################
career_area_bar.add_tools(TapTool(renderers=[bar],
callback = callback_career))
select_experience = Select(
title="Select postings that require experience of:",
value='All',
options= ['All', 'None', 'At least 1 year', 'At least 2 year'],
callback = callback_experience)
#Display data
multi_filter = VBox(widgetbox(select_experience), career_area_bar)
tot = HBox(multi_filter, gridplot([[mp]]))
output_notebook()
handle = show(tot, notebook_handle=True)
push_notebook(handle)
#show(tot)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="6bYaCABobL5q"
# ##### Copyright 2018 The TensorFlow Authors.
# + cellView="form" id="FlUw7tSKbtg4"
#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# + [markdown] id="08OTcmxgqkc2"
# # コードを TensorFlow 2 に自動的にアップグレードする
#
# <table class="tfo-notebook-buttons" align="left">
# <td> <a target="_blank" href="https://www.tensorflow.org/guide/upgrade"> <img src="https://www.tensorflow.org/images/tf_logo_32px.png"> TensorFlow.orgで表示</a>
# </td>
# <td> <a target="_blank" href="https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/ja/guide/upgrade.ipynb"> <img src="https://www.tensorflow.org/images/colab_logo_32px.png"> Google Colabで実行</a>
# </td>
# <td><a target="_blank" href="https://github.com/tensorflow/docs-l10n/blob/master/site/ja/guide/upgrade.ipynb"> <img src="https://www.tensorflow.org/images/GitHub-Mark-32px.png"> GitHubでソースを表示</a></td>
# <td> <a target="_blank" href="https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/ja/guide/upgrade.ipynb"><img src="https://www.tensorflow.org/images/download_logo_32px.png">ノートブックをダウンロード</a>
# </td>
# </table>
#
# + [markdown] id="hZSaRPoybOp5"
# TensorFlow 2.0には引数の並べ替え、シンボル名の変更、パラメータのデフォルト値の変更など、多くのAPIの変更が含まれています。これらの変更をすべて手動で実行するのは退屈で、エラーが発生しやすくなります。変更を合理化し、可能な限りシームレスに TF 2.0 に移行できるよう、TensorFlow チームはレガシーコードの新しい API への移行を支援する `tf_upgrade_v2` ユーティリティを作成しています。
#
# 注意: `tf_upgrade_v2` は TensorFlow 1.13 以降（すべての TF 2.0 ビルドを含む）に自動的にインストールされています。
#
# 一般的な使用方法は以下のとおりです。
#
# <pre class="devsite-terminal devsite-click-to-copy prettyprint lang-bsh">tf_upgrade_v2 \<br> --intree my_project/ \<br> --outtree my_project_v2/ \<br> --reportfile report.txt</pre>
#
# これにより、既存の TensorFlow 1.x Python スクリプトが TensorFlow 2.0 に変換され、アップグレード処理が高速化します。
#
# この変換スクリプトは可能な限り自動化を行いますが、スクリプトでは実行できない構文やスタイルの変更もあります。
# + [markdown] id="gP9v2vgptdfi"
# ## 互換性モジュール
#
# いくつかの API シンボルは単に文字列置換を使用するだけではアップグレードできません。コードを確実に TensorFlow 2.0 に対応させるため、アップグレードスクリプトには `compat.v1` モジュールが含まれています。このモジュールは `tf.foo` のような TF 1.x のシンボルを同等の `tf.compat.v1.foo` 参照に置換します。この互換性モジュールは優れていますが、置換箇所を手作業で見直し、それらを `tf.compat.v1` 名前空間ではなく `tf.*` 名前空間の新しい API に早急に移行することをお勧めします。
#
# TensorFlow 2.x で廃止されているモジュール（`tf.flags` や `tf.contrib` など）があるため、一部の変更は `compat.v1` に切り替えても対応できません。このようなコードをアップグレードするには、追加のライブラリ（[`absl.flags`](https://github.com/abseil/abseil-py) など）を使用するか、[tensorflow/addons](http://www.github.com/tensorflow/addons) にあるパッケージに切り替える必要があるかもしれません。
#
# + [markdown] id="s78bbfjkXYb7"
# ## 推奨アップグレード手順
#
# このガイドの残りの部分では、アップグレードスクリプトの使用方法を説明します。アップグレードスクリプトは簡単に使用できますが、次の手順の一環として使用することを強く推奨します。
#
# 1. **単体テスト**: アップグレード対象のコードにカバレッジ率が適度な単体テストスイートを確実に用意します。このコードは Python で記述されているため、さまざまなミスから保護されることはありません。また、すべての依存物が TensorFlow 2.0 との互換性を確保できるようにアップグレード済みであることを確認してください。
#
# 2. **TensorFlow 1.14 のインストール**: TensorFlow を最新の TensorFlow 1.x バージョン（1.14 以上）にアップグレードします。このバージョンには `tf.compat.v2` に最終的な TensorFlow 2.0 API が含まれています。
#
# 3. **1.14 でテスト**: この時点で単体テストに合格することを確認します。単体テストはアップグレード中に何度も実行することになるため、安全な状態で開始することが重要です。
#
# 4. **アップグレードスクリプトの実行**: テストを含むソースツリー全体で `tf_upgrade_v2` を実行します。これにより、TensorFlow 2.0 で利用できるシンボルのみを使用する形式にコードがアップグレードされます。廃止されたシンボルは `tf.compat.v1` でアクセスできます。このようなシンボルは最終的には手動での対応が必要ですが、すぐに対応する必要はありません。
#
# 5. **変換後のテストを TensorFlow 1.14 で実行**: コードは引き続き TensorFlow 1.14 で正常に動作するはずです。もう一度単体テストを実行してください。テストで何らかのエラーが発生する場合は、アップグレードスクリプトにバグがあります。その場合は[お知らせください](https://github.com/tensorflow/tensorflow/issues)。
#
# 6. **アップグレードレポートの警告とエラーを確認**: このスクリプトは再確認が必要な変換や、必要な手動対応を説明するレポートファイルを書き出します。たとえば、残っているすべての contrib インスタンスを手動で削除する必要がある場合などです。[RFC で詳細](https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md)を確認してください。
#
# 7. **TensorFlow 2.0 のインストール**: この時点で TensorFlow 2.0 に切り替えても安全です。
#
# 8. **`v1.disable_v2_behavior` でのテスト**: テストの main 関数で `v1.disable_v2_behavior()` を使用してテストをもう一度実行すると、1.14 で実行した場合と同じ結果になるはずです。
#
# 9. **V2の動作を有効化**: テストが v2 API を使用して動作するようになったため、v2 の動作をオンにすることを検討し始めることができます。コードの記述方法によっては、若干の変更が必要になる場合があります。詳細については、[移行ガイド](migrate.ipynb)を参照してください。
# + [markdown] id="6pwSAQEwvscP"
# ## アップグレードスクリプトの使用
#
# + [markdown] id="I9NCvDt5GwX4"
# ### セットアップ
#
# 始める前に、TensorlFlow 2.0 がインストールされていることを確認してください。
# + id="DWVYbvi1WCeY"
import tensorflow as tf
print(tf.__version__)
# + [markdown] id="Ycy3B5PNGutU"
# テスト対象のコードがある [tensorflow/models](https://github.com/tensorflow/models) git リポジトリをクローンします。
# + id="jyckoWyAZEhZ"
# !git clone --branch r1.13.0 --depth 1 https://github.com/tensorflow/models
# + [markdown] id="wfHOhbkgvrKr"
# ### ヘルプを読む
#
# スクリプトは TensorFlow と共にインストールされています。組み込みのヘルプは次のとおりです。
# + id="m2GF-tlntqTQ"
# !tf_upgrade_v2 -h
# + [markdown] id="se9Leqjm1CZR"
# ### TF1 のコード例
# + [markdown] id="whD5i36s1SuM"
# 単純な TensorFlow 1.0 のスクリプトは次のとおりです。
# + id="mhGbYQ9HwbeU"
# !head -n 65 models/samples/cookbook/regression/custom_regression.py | tail -n 10
# + [markdown] id="UGO7xSyL89wX"
# TensorFlow 2.0 がインストールされている状態では動作しません。
# + id="TD7fFphX8_qE"
!(cd models/samples/cookbook/regression && python custom_regression.py)
# + [markdown] id="iZZHu0H0wLRJ"
# ### 単一ファイル
#
# アップグレードスクリプトは単体の Python ファイルに対して実行できます。
# + id="xIBZVEjkqkc5"
# !tf_upgrade_v2 \
# --infile models/samples/cookbook/regression/custom_regression.py \
# --outfile /tmp/custom_regression_v2.py
# + [markdown] id="L9X2lxzqqkc9"
# コードの修正策が見つからない場合、スクリプトはエラーを出力します。
# + [markdown] id="r7zpuE1vWSlL"
# ### ディレクトリツリー
# + [markdown] id="2q7Gtuu8SdIC"
# この単純な例を含む一般的なプロジェクトでは、複数のファイルが使用されています。通常はパッケージ全体をアップグレードするため、スクリプトをディレクトリツリーに対して実行することもできます。
# + id="XGqcdkAPqkc-"
# upgrade the .py files and copy all the other files to the outtree
# !tf_upgrade_v2 \
# --intree models/samples/cookbook/regression/ \
# --outtree regression_v2/ \
# --reportfile tree_report.txt
# + [markdown] id="2S4j7sqbSowC"
# `dataset.make_one_shot_iterator` 関数に関して警告が 1 つ表示されていることに注意してください。
#
# これで、スクリプトが TensorFlow 2.0 で動作するようになりました。
#
# `tf.compat.v1` モジュールのため、変換後のスクリプトは TensorFlow 1.14 でも実行されることに注意してください。
# + id="vh0cmW3y1tX9"
!(cd regression_v2 && python custom_regression.py 2>&1) | tail
# + [markdown] id="4EgZGGkdqkdC"
# ## 詳細レポート
#
# このスクリプトは、詳細な変更のリストも報告します。この例では安全でない可能性のある変換が 1 つ検出され、ファイルの先頭で警告が表示されています。
# + id="CtHaZbVaNMGV"
# !head -n 20 tree_report.txt
# + [markdown] id="1-UIFXP3cFSa"
# 再度 `Dataset.make_one_shot_iterator function` に関して警告が 1 つ表示されていることに注意してください。
# + [markdown] id="oxQeYS1TN-jv"
# その他の場合、重要な変更の根拠が出力されます。
# + id="WQs9kEvVN9th"
# %%writefile dropout.py
import tensorflow as tf
d = tf.nn.dropout(tf.range(10), 0.2)
z = tf.zeros_like(d, optimize=False)
# + id="7uOkacZsO3XX"
# !tf_upgrade_v2 \
# --infile dropout.py \
# --outfile dropout_v2.py \
# --reportfile dropout_report.txt > /dev/null
# + id="m-J82-scPMGl"
# !cat dropout_report.txt
# + [markdown] id="DOOLN21nTGSS"
# 変更されたファイルの内容は次のとおりです。スクリプトがどのように引数名を追加し、移動および名前変更された引数を処理しているかに注目してください。
# + id="SrYcJk9-TFlU"
# !cat dropout_v2.py
# + [markdown] id="wI_sVNp_b4C4"
# 大規模なプロジェクトでは、若干のエラーが発生する可能性があります。たとえば、deeplab モデルを変換します。
# + id="uzuY-bOvYBS7"
# !tf_upgrade_v2 \
# --intree models/research/deeplab \
# --outtree deeplab_v2 \
# --reportfile deeplab_report.txt > /dev/null
# + [markdown] id="FLhw3fm8drae"
# 次のような出力ファイルが生成されました。
# + id="4YYLRxWJdSvQ"
# !ls deeplab_v2
# + [markdown] id="qtTC-cAZdEBy"
# しかし、エラーが発生していました。レポートは、実行前に修正する必要があるものを正確に把握するのに役立ちます。最初の 3 つのエラーは次のとおりです。
# + id="UVTNOohlcyVZ"
# !cat deeplab_report.txt | grep -i models/research/deeplab | grep -i error | head -n 3
# + [markdown] id="gGBeDaFVRJ5l"
# ## "Safety" モード
# + [markdown] id="BnfCxB7SVtTO"
# この変換スクリプトには `tensorflow.compat.v1` モジュールを使用するようにインポートを変更するだけの侵襲性の低い `SAFETY` モードもあります。
# + id="XdaVXCPWQCC5"
# !cat dropout.py
# + id="c0tvRJLGRYEb"
# !tf_upgrade_v2 --mode SAFETY --infile dropout.py --outfile dropout_v2_safe.py > /dev/null
# + id="91suN2RaRfIV"
# !cat dropout_v2_safe.py
# + [markdown] id="EOzTF7xbZqqW"
# ご覧のとおり、このモードはコードをアップグレードしませんが、TensorFlow 1 のコードを TensorFlow 2 で実行できます。
# + [markdown] id="jGfXVApkqkdG"
# ## 警告
#
# - このスクリプトを実行する前に手動でコードの一部をアップデートしないでください。特に、`tf.argmax` や `tf.batch_to_space` などの引数の順序が変更された関数により、既存コードを誤ってマッピングするキーワード引数が不正に追加されてしまいます。
#
# - このスクリプトは `tensorflow` が `import tensorflow as tf` を使用してインポートされていることを前提としています。
#
# - このスクリプトは引数の順序を変更しません。その代わり、キーワード引数を引数の順序が変更された関数に追加します。
#
# - GitHub リポジトリ内の Jupyter ノートブックと Python ファイルをアップグレードするための便利なツールについては、[tf2up.ml](http://tf2up.ml) をチェックしてください。
#
# アップグレードスクリプトのバグの報告または機能リクエストを行うには、[GitHub](https://github.com/tensorflow/tensorflow/issues) で課題を報告してください。また、TensorFlow 2.0 をテストしている場合は結果をお聞かせください！[TF 2.0 テストコミュニティ](https://groups.google.com/a/tensorflow.org/forum/#!forum/testing)に参加し、質問や議論を [testing@tensorflow.org](mailto:testing@tensorflow.org) 宛に投稿してください。
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
from pathlib import Path
import pandas as pd
import re
from scipy.io.arff import loadarff
# -
path_with_files = Path(r"C:\Users\zbenm\Mammals")
# +
file = "mammals.arff"
#file = "commonmammals.arff"
data, meta = loadarff(path_with_files / file)
# -
df = pd.DataFrame(data); df.shape
df.head()
# +
columns = df.columns
r = re.compile('^bio')
bio_columns = [col for col in columns if r.match(col)]
r = re.compile('^[A-Z]')
mammal_columns = [col for col in columns if r.match(col)]
location_columns = ['latitude', 'longitude']
monthly_columns = [col for col in columns if col not in set(mammal_columns) | set(bio_columns) | set(location_columns)]
# -
df['cell_id'] = df.index
df_grid_cell = df[['cell_id'] + location_columns + bio_columns]; df_grid_cell.shape
df_grid_cell.head()
df_monthly_v1 = df[['cell_id'] + monthly_columns]; df_monthly_v1.shape
df_monthly_v1.head()
df_monthly_v2 = df_monthly_v1.melt(id_vars=['cell_id']); df_monthly_v2.shape
df_monthly_v2.head()
df_monthly_v2[['statistics', 'month']] = pd.DataFrame.from_records(
df_monthly_v2['variable'].str.split('_').apply(lambda l: ('_'.join(l[:-2]), '_'.join(l[-2:])))
); df_monthly_v2.shape
df_monthly_v2.head()
df_monthly_v3 = df_monthly_v2.pivot(values='value',
index=['cell_id', 'month'],
columns=['statistics']).reset_index(); df_monthly_v3.shape
df_monthly_v3.head()
df_mammals_v1 = df[['cell_id'] + mammal_columns]; df_mammals_v1.shape
df_mammals_v1.head()
df_mammals_v2 = df_mammals_v1.melt(id_vars='cell_id'); df_mammals_v2.shape
df_mammals_v2.head()
df_mammals_v2['value'] = df_mammals_v2['value'] == b'1'
df_mammals_v2['value'].describe()
how_many_mammals = (
df_mammals_v2
.groupby('cell_id')
.agg(count_animals=('value', 'sum'))
.sort_values('count_animals', ascending=False)
)
# +
# for example, now we want to show a map with the number of animals,
# and see if it makes sense (my intuition, near cities less animals, rural places more mammals)
# +
# I'm going to build a primitive map, and later with Streamlit, I'll use more aqurate maps that they suggest to use.
# -
import matplotlib.pyplot as plt
# +
merged_df = how_many_mammals.merge(df_grid_cell, on='cell_id')
x, y, count = merged_df['longitude'], merged_df['latitude'], merged_df['count_animals']
plt.figure(figsize=(10, 6))
plt.scatter(x, y, c = count, s=20)
plt.title('count mammal kinds')
plt.colorbar()
plt.show();
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Self-Driving Car Engineer Nanodegree
#
#
#
# ## Project: Build a Traffic Sign Recognition Classifier
#
# ---
# ## Step 0: Load The Data
# +
import pickle
import os
import pandas as pd
import numpy as np
import tensorflow as tf
training_file = '/home/devesh/Downloads/traffic-signs-data/train.p'
validation_file= '/home/devesh/Downloads/traffic-signs-data/valid.p'
testing_file = '/home/devesh/Downloads/traffic-signs-data/test.p'
with open(training_file, mode='rb') as f:
train = pickle.load(f)
with open(validation_file, mode='rb') as f:
valid = pickle.load(f)
with open(testing_file, mode='rb') as f:
test = pickle.load(f)
X_train, y_train = train['features'], train['labels']
X_valid, y_valid = valid['features'], valid['labels']
X_test, y_test = test['features'], test['labels']
# -
X_train.shape
# ---
#
# ## Step 1: Dataset Summary & Exploration
#
# The pickled data is a dictionary with 4 key/value pairs:
#
# - `'features'` is a 4D array containing raw pixel data of the traffic sign images, (num examples, width, height, channels).
# - `'labels'` is a 1D array containing the label/class id of the traffic sign. The file `signnames.csv` contains id -> name mappings for each id.
# - `'sizes'` is a list containing tuples, (width, height) representing the original width and height the image.
# - `'coords'` is a list containing tuples, (x1, y1, x2, y2) representing coordinates of a bounding box around the sign in the image. **THESE COORDINATES ASSUME THE ORIGINAL IMAGE. THE PICKLED DATA CONTAINS RESIZED VERSIONS (32 by 32) OF THESE IMAGES**
#
# Complete the basic data summary below. Use python, numpy and/or pandas methods to calculate the data summary rather than hard coding the results. For example, the [pandas shape method](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.shape.html) might be useful for calculating some of the summary results.
# ### Provide a Basic Summary of the Data Set Using Python, Numpy and/or Pandas
# +
### Replace each question mark with the appropriate value.
### Use python, pandas or numpy methods rather than hard coding the results
# TODO: Number of training examples
n_train = X_train.shape[0]
# TODO: Number of validation examples
n_validation = X_valid.shape[0]
# TODO: Number of testing examples.
n_test = X_test.shape[0]
# TODO: What's the shape of an traffic sign image?
image_shape = X_test.shape[2]
# TODO: How many unique classes/labels there are in the dataset.
n_classes = np.unique(y_train).size
print("Number of training examples =", n_train)
print("Number of testing examples =", n_test)
print("Image data shape =", image_shape)
print("Number of classes =", n_classes)
# +
### Data exploration visualization goes here.
### Feel free to use as many code cells as needed.
import matplotlib.pyplot as plt
import random
# Visualizations will be shown in the notebook.
# %matplotlib inline
# show image of 10 random data points
fig, axs = plt.subplots(2,5, figsize=(15, 6))
fig.subplots_adjust(hspace = .2, wspace=.001)
axs = axs.ravel()
for i in range(10):
index = random.randint(0, len(X_train))
image = X_train[index]
axs[i].axis('off')
axs[i].imshow(image.squeeze())
axs[i].set_title(y_train[index])
fig.savefig('/home/devesh/1.png')
# +
fig2=plt.hist(y_train, bins = n_classes)
total_n_train = len(X_train)
print("Total number of training examples =", total_n_train)
plt.savefig('/home/devesh/2.png')
# +
import cv2
# Grayscales an image
def grayscale(img):
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
return img
def normalize(data):
return data / 255 * 0.8 + 0.1
def preprocess(data):
gray_images = []
for image in data:
gray = grayscale(image)
gray_images.append(gray)
return np.array(gray_images)
# +
from numpy import newaxis
print('Preprocessing training data...')
# Iterate through grayscale
X_train = preprocess(X_train)
X_train = X_train[..., newaxis]
# Normalize
X_train = normalize(X_train)
print('Finished preprocessing training data.')
# Double-check that the image is changed to depth of 1
image_shape2 = X_train.shape
print("Processed training data shape =", image_shape2)
print('Preprocessing testing data...')
# Iterate through grayscale
X_test = preprocess(X_test)
X_test = X_test[..., newaxis]
# Normalize
X_test = normalize(X_test)
print('Finished preprocessing testing data.')
# Double-check that the image is changed to depth of 1
image_shape3 = X_test.shape
print("Processed testing data shape =", image_shape3)
print('All data preprocessing complete.')
# +
# Generate additional data
from scipy import ndimage
import random
# min_desired below is just mean_pics but wanted to make the code below easier to distinguish
pics_in_class = np.bincount(y_train)
mean_pics = int(np.mean(pics_in_class))
min_desired = int(mean_pics)
print('Generating new data.')
# Angles to be used to rotate images in additional data made
angles = [-10, 10, -15, 15, -20, 20]
# Iterate through each class
for i in range(len(pics_in_class)):
# Check if less data than the mean
if pics_in_class[i] < min_desired:
# Count how many additional pictures we want
new_wanted = min_desired - pics_in_class[i]
picture = np.where(y_train == i)
more_X = []
more_y = []
# Make the number of additional pictures needed to arrive at the mean
for num in range(new_wanted):
# Rotate images and append new ones to more_X, append the class to more_y
more_X.append(ndimage.rotate(X_train[picture][random.randint(0,pics_in_class[i] - 1)], random.choice(angles), reshape=False))
more_y.append(i)
# Append the pictures generated for each class back to the original data
X_train = np.append(X_train, np.array(more_X), axis=0)
y_train = np.append(y_train, np.array(more_y), axis=0)
print('Additional data generated. Any classes lacking data now have', min_desired, 'pictures.')
# +
# Splitting the training dataset into training and validation data
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
# Shuffle the data prior to splitting
X_train, y_train = shuffle(X_train, y_train)
X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, stratify = y_train, test_size=0.1, random_state=23)
print('Dataset successfully split for training and validation.')
# +
import tensorflow as tf
tf.reset_default_graph()
EPOCHS = 10
BATCH_SIZE = 150
from tensorflow.contrib.layers import flatten
def myLeNet(x):
# Hyperparameters
mu = 0
sigma = 0.1
# Layer 1: Convolutional. Input = 32x32x1. Output = 28x28x6.
# Weight and bias
# If not using grayscale, the third number in shape would be 3
c1_weight = tf.Variable(tf.truncated_normal(shape = (5, 5, 1, 6), mean = mu, stddev = sigma))
c1_bias = tf.Variable(tf.zeros(6))
# Apply convolution
conv_layer1 = tf.nn.conv2d(x, c1_weight, strides=[1, 1, 1, 1], padding='VALID') + c1_bias
# Activation for layer 1
conv_layer1 = tf.nn.relu(conv_layer1)
# Pooling. Input = 28x28x6. Output = 14x14x6.
conv_layer1 = tf.nn.avg_pool(conv_layer1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
# Layer 2: Convolutional. Output = 10x10x16.
# Note: The second layer is implemented the exact same as layer one, with layer 1 as input instead of x
# And then of course changing the numbers to fit the desired ouput of 10x10x16
# Weight and bias
c2_weight = tf.Variable(tf.truncated_normal(shape = (5, 5, 6, 16), mean = mu, stddev = sigma))
c2_bias = tf.Variable(tf.zeros(16))
# Apply convolution for layer 2
conv_layer2 = tf.nn.conv2d(conv_layer1, c2_weight, strides=[1, 1, 1, 1], padding='VALID') + c2_bias
# Activation for layer 2
conv_layer2 = tf.nn.relu(conv_layer2)
# Pooling. Input = 10x10x16. Output = 5x5x16.
conv_layer2 = tf.nn.avg_pool(conv_layer2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
# Flatten to get to fully connected layers. Input = 5x5x16. Output = 400.
flat = tf.contrib.layers.flatten(conv_layer2)
# Layer 3: Fully Connected. Input = 400. Output = 120.
fc1_weight = tf.Variable(tf.truncated_normal(shape = (400, 200), mean = mu, stddev = sigma))
fc1_bias = tf.Variable(tf.zeros(200))
# Here is the main change versus a convolutional layer - matrix multiplication instead of 2D convolution
fc1 = tf.matmul(flat, fc1_weight) + fc1_bias
# Activation for the first fully connected layer.
# Same thing as before
fc1 = tf.nn.relu(fc1)
# Dropout, to prevent overfitting
fc1 = tf.nn.dropout(fc1, keep_prob)
# Layer 4: Fully Connected. Input = 120. Output = 84.
# Same as the fc1 layer, just with updated output numbers
fc2_weight = tf.Variable(tf.truncated_normal(shape = (200, 100), mean = mu, stddev = sigma))
fc2_bias = tf.Variable(tf.zeros(100))
# Again, matrix multiplication
fc2 = tf.matmul(fc1, fc2_weight) + fc2_bias
# Activation.
fc2 = tf.nn.relu(fc2)
# Dropout
fc2 = tf.nn.dropout(fc2, keep_prob)
# Layer 5 Fully Connected. Input = 84. Output = 43.
# Since this is the final layer, output needs to match up with the number of classes
fc3_weight = tf.Variable(tf.truncated_normal(shape = (100, 43), mean = mu, stddev = sigma))
fc3_bias = tf.Variable(tf.zeros(43))
# Again, matrix multiplication
logits = tf.matmul(fc2, fc3_weight) + fc3_bias
return logits
# +
# Set placeholder variables for x, y, and the keep_prob for dropout
# Also, one-hot encode y
x = tf.placeholder(tf.float32, (None, 32, 32, 1))
y = tf.placeholder(tf.int32, (None))
keep_prob = tf.placeholder(tf.float32)
one_hot_y = tf.one_hot(y, 43)
# +
rate = 0.005
logits = myLeNet(x)
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=one_hot_y, logits=logits)
loss_operation = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate = rate)
training_operation = optimizer.minimize(loss_operation)
# +
# The below is used in the validation part of the neural network
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1))
accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver()
def evaluate(X_data, y_data):
num_examples = len(X_data)
total_accuracy = 0
sess = tf.get_default_session()
for offset in range(0, num_examples, BATCH_SIZE):
batch_x, batch_y = X_data[offset:offset+BATCH_SIZE], y_data[offset:offset+BATCH_SIZE]
accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y, keep_prob : 1.0})
total_accuracy += (accuracy * len(batch_x))
return total_accuracy / num_examples
# -
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
num_examples = len(X_train)
print("Training...")
print()
for i in range(EPOCHS):
X_train, y_train = shuffle(X_train, y_train)
for offset in range(0, num_examples, BATCH_SIZE):
end = offset + BATCH_SIZE
batch_x, batch_y = X_train[offset:end], y_train[offset:end]
loss = sess.run(training_operation, feed_dict={x: batch_x, y: batch_y, keep_prob : 0.7})
validation_accuracy = evaluate(X_valid, y_valid)
print("EPOCH {} ...".format(i+1))
print("Validation Accuracy = {:.3f}".format(validation_accuracy))
print()
saver.save(sess, './lenet')
print("Model saved")
# +
# Launch the model on the test data
with tf.Session() as sess:
saver.restore(sess, './lenet')
test_accuracy = sess.run(accuracy_operation, feed_dict={x: X_test, y: y_test, keep_prob : 1.0})
print('Test Accuracy: {}'.format(test_accuracy))
# +
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
# Visualizations will be shown in the notebook.
# %matplotlib inline
add_pics = os.listdir("/home/devesh/udac_nd/CarND-Traffic-Sign-Classifier-Project/test/")
print(add_pics)
# Show the images, add to a list to process for classifying
add_pics_data = []
for i in add_pics:
i = '/home/devesh/udac_nd/CarND-Traffic-Sign-Classifier-Project/test/' + i
image = mpimg.imread(i)
add_pics_data.append(image)
plt.imshow(image)
plt.show()
# +
# Make into numpy array for processing
add_pics_data = np.array(add_pics_data)
# First, double-check the image shape to make sure it matches the original data's 32x32x3 size
print(add_pics_data.shape)
# +
add_pics_data = preprocess(add_pics_data)
add_pics_data = add_pics_data[..., newaxis]
# Normalize
add_pics_data = normalize(add_pics_data)
print('Finished preprocessing additional pictures.')
new_image_shape = add_pics_data.shape
print("Processed additional pictures shape =", new_image_shape)
# +
with tf.Session() as sess:
saver.restore(sess, './lenet')
new_pics_classes = sess.run(logits, feed_dict={x: add_pics_data, keep_prob : 1.0})
# +
### Visualize the softmax probabilities here.
### Feel free to use as many code cells as needed.
with tf.Session() as sess:
predicts = sess.run(tf.nn.top_k(new_pics_classes, k=5, sorted=True))
for i in range(len(predicts[0])):
print('Image', i, 'probabilities:', predicts[0][i], '\n and predicted classes:', predicts[1][i])
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3.8.1 64-bit ('.env')
# metadata:
# interpreter:
# hash: 75ce031803909c87d5abb7ecf93b814a68744b1af50690fb2477d0a013902920
# name: Python 3.8.1 64-bit ('.env')
# ---
# An interesting problem came up recently, there was a piece of code absolutely full of the same function calls over and over again, meaning if anything ever need to change, that would have to be changed in over 500 places, not ideal. Thoughts go back to single responsbility, and don't repeat yourself principles for software engineering. So research & thinking begun on the best way to manage this issue. The first thing that came to mind, how could we define these functions and their combinations iteratively.
#
# Before we dive into this could be implemented, we need to really understand the problem.
#
# The use case for this repeated code, was to check the variables being passed to an endpoint were what they were expected to be. For example, if an endpoint is awaiting for a string, and an optional number, we want to check these before the operation goes through and potentially breaks something else down the line (bringing us back to the crash early principle).
#
# We'll start by defining two functions which will check that a variable is the type it's expected to be, and another to ensure it exists (not None in Python).
# +
def check_type(value, variable_type, variable_name):
if type(value) != variable_type:
raise Exception(f"Variable '{variable_name}' is invalid type! Expected: {variable_type}.")
return value
def check_exists(value,variable_name):
if value is None:
raise Exception(f"Variable '{variable_name}' is None! Check variable exists.")
return value
# -
# Now that we've defined these functions, let's test that they work as expected and raise Exceptions when a problem statement comes up.
# +
check_type(24,int,'lucky_number')
check_type('Hello world', float, 'I thought this was a number')
# -
x = 55
y = None
check_exists(x,'Fifty five')
check_exists(y, 'Fifty six')
# ## Defining Functions Iteratively
#
# Now let's make use of the beauty that is looping to create all the combinations for us to use! We're going to encapsulate all these functions inside a dictionary to encapsulate them and provide a common interface for developers to use.
# +
def log_and_raise(exception_text):
# Add logging here
raise Exception(exception_text)
def create_validators(types):
validators = {}
for variable_type in types:
validators[f"{variable_type.__name__}"] = lambda value, variable_type=variable_type: value if type(value) == variable_type else log_and_raise(f"Variable isn't of type '{variable_type.__name__}'! D:")
return validators
validate = create_validators([str,float, int])
# -
# Now in a handful lines of code, we've created a dictionary with a way to easily generate functions to check variable types, and then log out the error (eg, write to a file) and raise an exception.
#
# Before we deconstruct what's happening here, let's see it in action.
# +
validate['str']('This is a string!')
validate['int'](42)
validate['float'](42.42)
x = 'The number forty two'
validate['str'](x)
# -
# Fantastic, as we can see, it's not throwing any errors and continuing through our validations, now let's ensure our exception is raised (and subsequently any logging would be completed).
validate['str'](42)
# Even better, we get raise an exception when our validation fails ensuring to alert the developers with information about why it failed. Now let's deconstruct how we created it in depth.
#
# ### Deconstruction of How
#
# Admittedly, there's a lot going on in those handful of lines which isn't obvious as to whats happening.
#
# First we define the overarching functions which contains the creation of all these functions, and thereafter initialise a dictionary to store all the following functions within. Next we loop over each of the types provided as a list to the function to create an entry in the dictionary using the `__name__` dunder function (eg, `str` has a dunder `__name__` of 'str'), this let's our developers use the type they want as the key of the dictionary when wanting to validate a variables type.
#
# ### Lambdas!
#
# The trickiest part here is how we are actually defining the functions. We make use of the lambda operator in Python to create **anonymous functions**. The structure of a lambda function definition follows:
#
# ``` Python
# lambda arguments: true_statement if conditional_statement else false_statement
# ```
#
# We make use of a keyword argument of the `variable_type` in our loop otherwise the `variable_type` from the list passed in won't be correctly passed into the lambda function (which we won't discuss in this post).
#
# Finally we make use of an external function to centralise how we handle errors (making it easy to keep a consistent logging approach), and raise an Exception within that function to ensure any logging occurs before the program ultimately exits.
#
# ## Conclusion
#
# There are pros and cons to this approach to this problem.
#
# **Pros**:
#
# - Concise way of creating lots of functions
# - Consistent interface to use
# - Stores all similar functions inside one object (dictionary)
#
# **Cons**:
#
# - Not straightforward as to how it works
# - Not straightforward to change functionality
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import scipy.io
import numpy as np
from matplotlib import pyplot as plt
from filters import KalmanFilter
from utils import (
load_imu_data,
plot_xyz,
euler_from_gyro,
euler_from_acce,
euler_from_acce2,
)
dt, ts, gyro, acce = load_imu_data()
plot_xyz(ts, acce, 'Accelerometer')
plot_xyz(ts, gyro, 'Gyroscope')
# -
# # Naive Integration of Gyro
euler_g = euler_from_gyro(ts, gyro)
plot_xyz(ts, euler_g*180/np.pi, "Euler attitude from naive integration of gyro")
# # Attitude from Accelerometer Only
euler_a = euler_from_acce(acce)
plot_xyz(ts, euler_a[:, :2] * 180 / np.pi, "Euler attitude from accelerometer only with stationary assumption")
plot_xyz(ts, euler_from_acce2(acce)[:, :2] * 180 / np.pi, "Euler attitude from accelerometer only ver2")
# # Sensor fusion with Kalman Filter
# +
def gyro_to_quat_system_mat(gyro):
p, q, r = gyro.T
zeros = np.zeros_like(p)
return np.stack([
zeros, -p, -q, -r,
p, zeros, r, -q,
q, -r, zeros, p,
r, q, -p, zeros,
], axis=1).reshape(-1, 4, 4) / 2
def euler_to_quat(euler):
phi, theta, psi = euler.T
sin_phi = np.sin(phi / 2)
cos_phi = np.cos(phi / 2)
sin_theta = np.sin(theta / 2)
cos_theta = np.cos(theta / 2)
sin_psi = np.sin(psi / 2)
cos_psi = np.cos(psi / 2)
return np.stack([
cos_phi * cos_theta * cos_psi + sin_phi * sin_theta * sin_psi,
sin_phi * cos_theta * cos_psi - cos_phi * sin_theta * sin_psi,
cos_phi * sin_theta * cos_psi + sin_phi * cos_theta * sin_psi,
cos_phi * cos_theta * sin_psi - sin_phi * sin_theta * cos_psi,
], axis=1)
def quat_to_euler(quat):
w, x, y, z = quat.T
phi = np.arctan2(2*(y*z + w*x), 1 - 2*(x**2 + y**2))
theta = -np.arcsin(2*(x*z - w*y))
psi = np.arctan2(2*(x*y + w*z), 1 - 2*(y**2 + z**2))
return np.stack([phi, theta, psi], axis=1)
system_mat = gyro_to_quat_system_mat(gyro)
attitude_meas_from_acce = euler_to_quat(euler_a)
attitude_pred = np.zeros((len(ts), 4))
kf = KalmanFilter(
x0 = np.array([[1, 0, 0, 0]]).T,
P0 = np.eye(4),
A = None,
H = np.eye(4),
Q = np.eye(4) * 1e-4,
R = np.eye(4) * 10,
)
for i, (s, a) in enumerate(zip(system_mat, attitude_meas_from_acce)):
kf.A = np.eye(4) + dt * s
kf.update(a.reshape(4, 1))
attitude_pred[i] = kf.get().reshape(-1)
attitude_pred_euler = quat_to_euler(attitude_pred) * 180 / np.pi
plot_xyz(ts, attitude_pred_euler[:, :2], "Attitude prediction from Kalman Filter")
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + id="z5QfYnKji-Iu"
import torch
import numpy as np
import random
def setup_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # if use multi-GPU
torch.backends.cudnn.deterministic = True
# torch.backends.cudnn.benchmark = True
np.random.seed(seed)
random.seed(seed)
# + id="JdUVVBpZHh2a"
import torch
import torchvision.ops
from torch import nn
class DeformableConv2d(nn.Module):
def __init__(self,
in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1,
bias=False):
super(DeformableConv2d, self).__init__()
self.padding = padding
self.offset_conv = nn.Conv2d(in_channels,
2 * kernel_size * kernel_size,
kernel_size=kernel_size,
stride=stride,
padding=self.padding,
bias=True)
nn.init.constant_(self.offset_conv.weight, 0.)
nn.init.constant_(self.offset_conv.bias, 0.)
self.modulator_conv = nn.Conv2d(in_channels,
1 * kernel_size * kernel_size,
kernel_size=kernel_size,
stride=stride,
padding=self.padding,
bias=True)
nn.init.constant_(self.modulator_conv.weight, 0.)
nn.init.constant_(self.modulator_conv.bias, 0.)
self.regular_conv = nn.Conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=self.padding,
bias=bias)
def forward(self, x):
h, w = x.shape[2:]
max_offset = max(h, w)/4.
offset = self.offset_conv(x).clamp(-max_offset, max_offset)
modulator = 2. * torch.sigmoid(self.modulator_conv(x))
x = torchvision.ops.deform_conv2d(input=x,
offset=offset,
weight=self.regular_conv.weight,
bias=self.regular_conv.bias,
padding=self.padding,
mask=modulator
)
return x
# + id="cFXGwYFAHsGs"
from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import StepLR
import torch
from torch import nn
class MNISTClassifier(nn.Module):
def __init__(self,
deformable=False):
super(MNISTClassifier, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1, bias=True)
self.conv2 = nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1, bias=True)
self.conv3 = nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1, bias=True)
conv = nn.Conv2d if deformable==False else DeformableConv2d
self.conv4 = conv(32, 32, kernel_size=3, stride=1, padding=1, bias=True)
self.conv5 = conv(32, 32, kernel_size=3, stride=1, padding=1, bias=True)
self.pool = nn.MaxPool2d(2)
self.gap = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(32, 10)
def forward(self, x):
x = torch.relu(self.conv1(x))
x = self.pool(x) # [14, 14]
x = torch.relu(self.conv2(x))
x = self.pool(x) # [7, 7]
x = torch.relu(self.conv3(x))
x = torch.relu(self.conv4(x))
x = torch.relu(self.conv5(x))
x = self.gap(x)
x = x.flatten(start_dim=1)
x = self.fc(x)
return x
def train(model, loss_function, device, train_loader, optimizer, epoch):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = loss_function(output, target)
loss.backward()
optimizer.step()
def test(model, loss_function, device, test_loader):
model.eval()
test_loss = 0
correct = 0
num_data = 0
with torch.no_grad():
for data, target in test_loader:
org_data, target = data.to(device), target.to(device)
for scale in np.arange(0.5, 1.6, 0.1): # [0.5, 0.6, ... ,1.2, 1.3, 1.4, 1.5]
data = transforms.functional.affine(org_data, scale=scale, angle=0, translate=[0,0],shear=0)
output = model(data)
test_loss += loss_function(output, target).item() # sum up batch mean loss
pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability
correct += pred.eq(target.view_as(pred)).sum().item()
num_data += len(data)
test_loss /= num_data
test_acc = 100. * correct / num_data
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
test_loss, correct, num_data,
test_acc))
return test_acc
def main(use_deformable_conv=False):
# Training settings
seed=1
setup_seed(seed)
use_cuda = torch.cuda.is_available()
batch_size = 64
lr=1e-3
gamma=0.7
epochs=14
device = torch.device("cuda" if use_cuda else "cpu")
train_kwargs = {'batch_size': batch_size}
test_kwargs = {'batch_size': batch_size}
if use_cuda:
cuda_kwargs = {'num_workers': 4,
'pin_memory': True,
'shuffle': True}
train_kwargs.update(cuda_kwargs)
test_kwargs.update(cuda_kwargs)
train_transform = transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
dataset1 = datasets.MNIST('./data', train=True, download=True,
transform=train_transform)
dataset2 = datasets.MNIST('./data', train=False,
transform=transform)
train_loader = torch.utils.data.DataLoader(dataset1,**train_kwargs)
test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)
model = MNISTClassifier(use_deformable_conv).to(device)
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = StepLR(optimizer, step_size=1, gamma=gamma)
loss_function = nn.CrossEntropyLoss()
best_test_acc = 0.
for epoch in range(1, epochs + 1):
train(model, loss_function, device, train_loader, optimizer, epoch)
best_test_acc = max(best_test_acc, test(model, loss_function, device, test_loader))
scheduler.step()
print("best top1 acc(%): ", f"{best_test_acc:.2f}")
# + colab={"base_uri": "https://localhost:8080/"} id="YDh26cxyKax5" executionInfo={"status": "ok", "timestamp": 1617890129011, "user_tz": -540, "elapsed": 189474, "user": {"displayName": "\uad8c\uc6a9\ud61c", "photoUrl": "", "userId": "13973451055019228775"}} outputId="6082fbac-7806-465b-8d2f-278371a7bfd2"
main(use_deformable_conv=False)
# + colab={"base_uri": "https://localhost:8080/"} id="gdDR8d9OKcOp" executionInfo={"status": "ok", "timestamp": 1617890361052, "user_tz": -540, "elapsed": 421503, "user": {"displayName": "\uad8c\uc6a9\ud61c", "photoUrl": "", "userId": "13973451055019228775"}} outputId="3a8f4539-3f5f-49fc-973c-8002c3fa76c8"
main(use_deformable_conv=True)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
import pandas as pd
df = pd.read_table('SMSSpamCollection', sep ='\t', names=['is_spam','message'])
df.head()
df['is_spam']=df['is_spam'].map({'spam':1,'ham':0})
df.head()
#Baseline Accuracy
1-df['is_spam'].mean()
# # OUR BASELINE IS 87%! Gotta beat this!
df['message_length']=df['message'].apply(lambda x: len(x))
df.head()
df.groupby('is_spam').describe()
df.corr()
df.shape
df.drop_duplicates('message',inplace=True)
df.shape
#New Baseline
1-df['is_spam'].mean()
from sklearn.feature_extraction.text import CountVectorizer
X=df['message']
y=df['is_spam']
vect = CountVectorizer(stop_words='english')
X_vect = vect.fit_transform(X)
X_vect
# # X_vect is a SPARSE MATRIX! Values located in matrix with a tuple showing location
print(X_vect)
df.loc[0,'message']
vect.get_feature_names()[2007]
X_vect.shape
# #### There are 5169 MESSAGES, with 8444 UNIQUE WORDS (after removing stop words)
dtm = pd.DataFrame(X_vect.toarray(), columns=vect.get_feature_names())
dtm.iloc[0:10,2000:2014]
dtm = pd.concat([dtm,df['is_spam']], axis=1)
dtm.head()
grouped = dtm.groupby('is_spam').mean().T.sort_values(1.0, ascending=False)
grouped.rename(columns={0:'ham',1:'spam'}, inplace=True)
grouped.head()
grouped['delta']=grouped['spam']-grouped['ham']
grouped.head()
grouped.sort_values('delta',ascending=False).head()
# # Suggested that Multinomial Naive Bayes might the best for this problem. HOwever, we haven't learned it yet!
# # So lets use LogisticRegression instead!
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score, train_test_split
cross_val_score(LogisticRegression(),X_vect,y,scoring='accuracy').mean()
# ##### 97.5%, piece of cake
# just to review, logistic regression assigns the BEST COEFFICIENTS to each FEATURE (each unique word) across all INSTANCES (SMS messages). It WEIGHTS the words to give us the most accurate predictions.
# stop words will drop all words in a given dictionary, max_features drops least frequent terms
# these parameters ultimately impact our model!
# binary True disregards how many times a word occurs, just focuses on whether it occurs or not
# ngram - clusters of words side by side
# min_df - word must occur in at least 2 documents, or minimum % of documents
# max_df - same as above, but for maximum
vect=CountVectorizer(
stop_words='english',
max_features=5000,
binary=True,
ngram_range=(1,2),
min_df=2,
max_df=.4)
X_vect = vect.fit_transform(X)
lr = LogisticRegression()
X_train, X_test, y_train, y_test = train_test_split(X_vect,y,random_state=2003)
lr.fit(X_train,y_train)
lr.coef_
coef = pd.DataFrame(lr.coef_.T, index=vect.get_feature_names(), columns=['coef'])
coef.sort_values('coef', ascending=False).head(10)
from sklearn import metrics
pred = lr.predict(X_test)
metrics.accuracy_score(y_test,pred)
metrics.confusion_matrix(y_test,pred)
print metrics.classification_report(y_test,pred)
# # what types of messages are we missing? trying to find the false positives!
test_df=df.loc[y_test.index,:].copy()
test_df['pred']=pred
test_df.head()
# BOOM! FALSE POSITIVES!
test_df.loc[(test_df['pred']==1) & (test_df['is_spam']==0),:]
# BOOM! FALSE NEGATIVES!
test_df.loc[(test_df['pred']==0) & (test_df['is_spam']==1),:]
lr.predict_proba(X_test)
prob = lr.predict_proba(X_test)[:,1]
fpr,tpr,thresholds = metrics.roc_curve(y_test,prob)
import matplotlib.pyplot as plt
# %matplotlib inline
#This ROC curve plots the true positive rate vs false positive rate at various threshold settings.
plt.plot(fpr,tpr)
plt.plot(fpr,thresholds, color='red')
# HERE I AM CHANGING MY PREDICTIONS BASED ON A NEW THRESHOLD OF 0.1
test_df['prob'] = prob
test_df['pred'] = test_df['prob'].apply(lambda x: 1 if x > .1 else 0)
test_df.head()
# # OKAY, BACK TO VECTORIZER. IF WE PUT IT IN A PIPELINE, WE CAN TUNE OUR VECTORIZER FEATURES!!!!
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
pipe=Pipeline([('vect',CountVectorizer()),('lr',LogisticRegression())])
params = {
'vect__binary':[True,False],
'vect__stop_words':[None,'english'],
'lr__penalty':['l1','l2'],
'vect__ngram_range':[(1,1),(1,2),(1,3)],
'vect__min_df': range(1,5)
}
gs = GridSearchCV(pipe, param_grid=params, cv=5, scoring='accuracy')
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=2003)
gs.fit(X_train, y_train)
gs.best_score_
gs.best_params_
# # No need to clean data first, can just predict on test, and pipeline takes care of it!!!
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: lhl-bootcamp
# language: python
# name: lhl-bootcamp
# ---
# # Gift Recommender Engine: Topic Classification Evaluation
# This notebook outlines the approaches my attempts to evaluate the performance of my topic model on actual tweets. To get a sense of how my model is performing, I will test my classifier on the following tweets:
#
# 1. <b> Company Tweets </b>: This can be used as a proof-of-concept baseline test of the approach. Companies should be very distinct (ex. ESPN should predict sports, etc), so it may give a picture if the classifier is going on the right approach.
# 2. <b> Celebrity Tweets </b>: Celebrity's Tweets - we have some understanding of what a celebrity may or may not like (whether they are a singer, actor, or athlete). This way, we can test how the model is doing on specific users.
#
#
# The implementation of the model on tweets can be outlined as followed:
#
# 1. Clean tweets using preprocessing function to remove links, stopwords, etc.
# 2. Perform sentiment analysis on each tweet and filter tweets that contain positive sentiment. The idea here is that if a user tweets positively about something, that means they like that particular topic and can be gifted that item.
# 3. Input each tweet into the topic classifier, built out of a linear support vector classifier. Each tweet will generate a certain topic and a probability (i.e how confident the model is at predicting that particular topic).
# 4. Filter topics that have a confidence threshold greater than a certain point as to filter noise.
# 5. Count the most topics of tweets by the user. The top 3 topics will correspond to categories that the user might enjoy.
# ## Import Libraries, Functions, and Models
import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
import matplotlib.pyplot as plt
import seaborn as sns
# +
# Import Models
import pickle
# Naive Bayes Model
filename = open('models/nb_baseline2.sav', 'rb')
nb = pickle.load(filename)
# Support Vector Classifier Model
filename = open('models/linear_svc_baseline2.sav', 'rb')
ovr_svc = pickle.load(filename)
# Import Vectorizer
filename = open('models/tfidf_vectorizer2.sav', 'rb')
tfidf_model = pickle.load(filename)
# Import Reference Dictionary
filename = open('models/reference-dict.pickle', 'rb')
ref = pickle.load(filename)
# +
# Cleaning Functions
import re
import string
import nltk
import spacy
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
stopwords = nltk.corpus.stopwords.words('english')
stopwords.extend(['im', "oh", "i'm", "lol", "gonna", 'ill'])
nlp = spacy.load('en_core_web_sm')
def spacy_lemmatize(text):
if type(text) == list:
doc = nlp(u"{}".format(' '.join(text)))
else:
doc = nlp(u"{}".format(text))
lemmatized = list()
for token in doc:
lemmatized.append(token.lemma_)
return lemmatized
def deEmojify(text):
regrex_pattern = re.compile(pattern = "["
u"\U0001F600-\U0001F64F" # emoticons
u"\U0001F300-\U0001F5FF" # symbols & pictographs
u"\U0001F680-\U0001F6FF" # transport & map symbols
u"\U0001F1E0-\U0001F1FF" # flags (iOS)
"]+", flags = re.UNICODE)
return regrex_pattern.sub(r'',text)
def tweet_preprocess(text):
text=re.sub(r'http\S+', '',text)
text = re.sub('@[^\s]+','',text)
text = re.sub('</?[a-z]+>', '', text)
text = text.replace('&', '&')
text = re.sub(r"[^\w\s]", "", text)
text = deEmojify(text)
text = text.split() #split into list
#text = [re.sub(r'^https?:\/\/.*[\r\n]*', '', s, flags=re.MULTILINE) for s in text] #remove any links
#text = [re.sub('@[^\s]+','', s) for s in text] #remove @
text = [s.lower() for s in text] #convert every character into lowercase
#text = [re.sub(rf"[{string.punctuation}]", " ", s) for s in text] #remove punctuations
text = [re.sub(r'[0-9]', ' ', s) for s in text] #remove all digits
text = ' '.join(text) #resplits
text = [s for s in text.split() if len(s) >= 2] #removes words with one word length
text = [s for s in text if s not in stopwords] #remove all stopwords
text = ' '.join(spacy_lemmatize(text)) #lemmatize text using spacy and join into a string
text = ' '.join([s for s in text.split() if len(s) > 2])
return text
class TweetCategory:
def __init__(self, model, vectorizer, tweet_data, reference):
self.data = tweet_data
self.model = model
self.vectorizer = vectorizer
self.ref = reference
self.analyzer = SentimentIntensityAnalyzer()
def process_user_tweets(self):
self.data['clean-tweet'] = self.data['Tweet Content'].map(tweet_preprocess)
self.data = self.data[['Tweet Content', 'clean-tweet']].rename(columns={'Tweet Content': 'tweet'})
self.data['vader-sentiment'] = self.data['tweet'].apply(lambda x: self.analyzer.polarity_scores(x))
self.data['vader-pos'] = self.data['vader-sentiment'].apply(lambda x: x['pos'])
self.data['vader-neu'] = self.data['vader-sentiment'].apply(lambda x: x['neu'])
self.data['vader-neg'] = self.data['vader-sentiment'].apply(lambda x: x['neg'])
self.data['vader-compound'] = self.data['vader-sentiment'].apply(lambda x: x['compound'])
def predict_topics(self, sentiment_thresh, confidence_thresh):
self.predict_df = self.data[(self.data['vader-compound'] >= sentiment_thresh) & (self.data['clean-tweet'] != '')]
tweets_transformed = self.vectorizer.transform(self.predict_df['clean-tweet'])
predicted_category = self.model.predict(tweets_transformed)
p = np.array(self.model.decision_function(tweets_transformed))
probability = np.exp(p)/np.sum(np.exp(p), axis=1, keepdims=True)
probability_list = [max(prob) for prob in probability]
self.predict_df['predicted'] = predicted_category
self.predict_df['probability'] = probability_list
self.predict_df['predicted'] = self.predict_df['predicted'].apply(lambda x: self.ref[x])
top_categories = self.predict_df[self.predict_df['probability'] >= confidence_thresh]['predicted'].value_counts()[:3]
return top_categories
# -
# ## Testing on Company Tweets
# ### 1. ESPN
#
# If this model is valid, it should overwhelmingly categorize ESPN as a sports channel. Let's test this approach!
espn = pd.read_csv('datasets/twitter-profiles/report_espn/tweets.csv')
espn.head()
key = {v: k for k, v in ref.items()}
espn_model = TweetCategory(ovr_svc, tfidf_model, espn, key)
espn_model.process_user_tweets()
top_categories = espn_model.predict_topics(0, 0.2)
top_categories
# +
espn_df = espn_model.predict_df
total_len = len(espn_df[espn_df.probability >= 0.2])
round(top_categories/total_len*100, 1)
# -
# The model overwhelmingly predicted sports! It's on the right track! Let's evaluate the model on other company platforms.
# ### 2. Youtube
#
# This is a little bit tricky - Youtube can contain a variety of different platforms. If this model is valid, it should predict topics like movies and music. Weird topics will be books, alcohol, and travel.
youtube = pd.read_csv('datasets/twitter-profiles/report_youtube/tweets.csv')
youtube.head()
youtube_model = TweetCategory(ovr_svc, tfidf_model, youtube, ref)
youtube_model.process_user_tweets()
top_categories = youtube_model.predict_topics(0, 0.2)
print(top_categories)
# Seems to predict movies and music quite well! Nature seems slightly odd, but let's have a look.
youtube_df = youtube_model.predict_df
youtube_df[(youtube_df['predicted'] =='Nature') & (youtube_df['probability']>=0.2)]['tweet'].to_list()[:30]
# For the most part the tweets seem overwhelmingly about nature (raising money for Team Trees, recommending things about sustainability).
# ### 3. NASA
#
# This may be a challenging one as well, but out of the categories, I will expect things like technology and nature. Completely wrong categories would be alcohol and household.
nasa = pd.read_csv('datasets/twitter-profiles/report_nasa/tweets.csv')
nasa.head()
nasa_model = TweetCategory(ovr_svc, tfidf_model, nasa, key)
nasa_model.process_user_tweets()
top_categories = nasa_model.predict_topics(0, 0.2)
print(top_categories)
top_categories
# +
nasa_df = nasa_model.predict_df
total_len = len(nasa_df[nasa_df.probability >= 0.2])
round(top_categories/total_len*100, 1)
# -
# The model predicts electronics and nature, which is very relevant! The next topic predicted is music, but this is 10 times less than the other two categories, which means it can very well be noise.
# ## Testing on Celebrity Tweets
# ### 1. Taylor Swift
#
# If this model is working well, I would expect the model to predict mainly music. Other acceptable categories can be: movies (she starred in some movies, I believe she also recorded songs for a few movies), books, and nature (she has a cat!). Unacceptable categories may be business, alcohol, household, and coffee.
tswift = pd.read_csv('datasets/twitter-profiles/report_taylorswift13/tweets.csv')
tswift.head(5)
tswift_model = TweetCategory(ovr_svc, tfidf_model, tswift, key)
tswift_model.process_user_tweets()
top_categories = tswift_model.predict_topics(0, 0.2)
print(top_categories)
# +
tswift_df = tswift_model.predict_df
total_len = len(tswift_df[tswift_df.probability >= 0.2])
round(top_categories/total_len*100, 1)
# -
# It predicts overwhelmingly music! Makes complete sense, since Taylor Swift is a musician and she promotes a lot of her music on Twitter.
# ### 2. The Ellen Show
# This might be a bit challenging. I expect movies to be one of the categories predicted(includes TV show), since Ellen hosts a daytime interview show. Concerning topics might be electronics, sports, food, coffee, and household, since they are not very relevant.
ellen = pd.read_csv('datasets/twitter-profiles/report_theellenshow/tweets.csv')
ellen.head()
ellen_model = TweetCategory(ovr_svc, tfidf_model, ellen, key)
ellen_model.process_user_tweets()
top_categories = ellen_model.predict_topics(0, 0.2)
print(top_categories)
# +
ellen_df = ellen_model.predict_df
total_len = len(ellen_df[ellen_df.probability >= 0.2])
round(top_categories/total_len*100, 1)
# -
# Predicted overwhelming movies! I was curious as to why it predicted Gaming and Nature, but I remembered Ellen has her own show about Games (Game of Games) and she plays a lot of games on her show with celebrities. Ellen is also an advocate for animals - she has the Ellen Wildlife Fund. Let's see if the tweets in these categories are in fact relevant!
ellen_df = ellen_model.predict_df
game_tweets = ellen_df[(ellen_df['probability'] >= 0.2) & (ellen_df['predicted'] == 'Gamers')]['tweet'].to_list()
nature_tweets = ellen_df[(ellen_df['probability'] >= 0.2) & (ellen_df['predicted'] == 'Nature')]['tweet'].to_list()
# Overall, seems to do a pretty good job. A few misclassifications - fashion seems to be predicted as nature and a few sports (like congratulating Naomi Osaka) is predicted as games, but overall, the tweets are quite relevant.
# ### 3. Barack Obama
obama = pd.read_csv('datasets/twitter-profiles/report_barackobama/tweets.csv')
obama.head(5)
obama_model = TweetCategory(ovr_svc, tfidf_model, obama, ref)
obama_model.process_user_tweets()
top_categories = obama_model.predict_topics(0, 0.2)
print(top_categories)
obama_df = obama_model.predict_df
nature_tweets = obama_df[(obama_df['predicted'] == 'Nature') & (obama_df['probability'] >= 0.2)]['tweet'].to_list()
sports_tweets = obama_df[(obama_df['predicted'] == 'Sports') & (obama_df['probability'] >= 0.2)]['tweet'].to_list()
care_tweets = obama_df[(obama_df['predicted'] == 'Self-care') & (obama_df['probability'] >= 0.2)]['tweet'].to_list()
print(nature_tweets[:30])
print(sports_tweets[:30])
print(care_tweets[:30])
# ## Compute Similarity Scores
# +
import gensim.downloader as api
model_glove_twitter = api.load("glove-twitter-25")
# +
def get_similarity_score(row):
doc = nlp(row['clean-tweet'])
sim_score = list()
for token in doc:
if token.pos_ == 'NOUN':
try:
sim_score.append(model_glove_twitter.similarity(token.text, row['predicted'].lower()))
except:
sim_score.append(0)
try:
average = sum(sim_score)/len(sim_score)
except:
average = 0
return average
def get_average_scores(df, conf_threshold):
over_list = df[df.probability >= conf_threshold]['score'].to_list()
under_list = df[df.probability < conf_threshold]['score'].to_list()
ave_over = sum(over_list)/len(over_list)
ave_under = sum(under_list)/len(under_list)
return [ave_over, ave_under]
def get_results(all_df, conf_threshold):
average_scores = list()
for df in all_df:
df.predict_df['score'] = df.predict_df.apply(get_similarity_score, axis=1)
average_scores.append(get_average_scores(df.predict_df, conf_threshold))
above = [i[0] for i in average_scores]
below = [i[1] for i in average_scores]
above_average = sum(above)/len(above)
below_average = sum(below)/len(below)
return [above_average, below_average]
# -
all_df = [espn_model, youtube_model, nasa_model, tswift_model, ellen_model, obama_model]
all_averages = list()
threshold = np.linspace(0.1, 0.3, 11)
for prob in threshold:
all_averages.append(get_results(all_df, prob))
average_df = pd.DataFrame(columns=['above', 'below'])
for i in all_averages:
average_df.loc[len(average_df)] = i
average_df['threshold'] = threshold
fig, ax = plt.subplots(figsize=(8, 6))
sns.lineplot(x="threshold", y="above", data=average_df,
label="Above Threshold", linestyle='--', marker='o', color='#a53860', ax=ax)
sns.lineplot(x="threshold", y="below", data=average_df,
label="Below Threshold", linestyle='--', marker='o', color='#ea8c55', ax=ax)
plt.xlabel('Model Confidence Threshold')
plt.ylabel('Similarity Score')
ax.set_ylim([0, 0.6])
ax.set_title('Affect of Confidence Threshold on Similarity Score', fontweight='bold', fontsize=12, y=1.05)
plt.legend(loc='lower right')
sns.despine()
results = pd.DataFrame(averages).rename(columns={0: 'sim_score'})
results['threshold'] = ['Greater than 0.2', 'Less than 0.2']
fig, ax = plt.subplots(figsize=(6, 6))
sns.set_style('ticks')
sns.barplot(x='threshold', y='sim_score', data=results, palette='flare_r', edgecolor='.2')
plt.xlabel('Confidence Threshold')
plt.ylabel('Tweet-Topic Similarity Score')
plt.title('Confidence Threshold vs. Tweet-Topic Similarity Score', fontweight='bold', fontsize=13)
sns.despine()
# ## Evaluating Classifier Using Topic Modelling
# Let's see if our model is able to capture the most predominant topics from a particular user by performing topic modelling on a user tweets. I will test this on Obama's Tweets.
from sklearn.decomposition import LatentDirichletAllocation,NMF
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
ellen_tweets = ellen_df[['tweet', 'clean-tweet']]
#ellen_tweets['clean-tweet'] = ellen_tweets['tweet'].map(tweet_preprocess)
tfidf_v = TfidfVectorizer(stop_words='english')
tfidf=tfidf_v.fit_transform(ellen_tweets['clean-tweet'])
tfidf_feature_names=tfidf_v.get_feature_names()
count_v = CountVectorizer(stop_words='english')
count=count_v.fit_transform(ellen_tweets['clean-tweet'])
count_feature_names=count_v.get_feature_names()
no_topics=5
nmf=NMF(n_components=no_topics, random_state=1, alpha=0.1, l1_ratio=0.5, init='nndsvd')
lda=LatentDirichletAllocation(n_components=no_topics, max_iter=5, learning_method='online', learning_offset=50,random_state=0)
nmf_output = nmf.fit_transform(tfidf)
lda_output = lda.fit_transform(tfidf)
# +
def display_topics(model, feature_names, no_top_words):
for topic_idx, topic in enumerate(model.components_):
print ("Topic %d:" % (topic_idx))
print (" ".join([feature_names[i] for i in topic.argsort()[:-no_top_words - 1:-1]]))
no_top_words = 20
display_topics(lda, tfidf_feature_names, no_top_words)
# -
display_topics(nmf, tfidf_feature_names, no_top_words)
# #### Only Nouns
# +
nlp = spacy.load("en_core_web_sm")
def get_nouns(text):
doc = nlp(text)
nouns = list()
for token in doc:
if token.pos_ == 'NOUN':
nouns.append(str(token))
return ' '.join(nouns)
# -
ellen_tweets['nouns'] = ellen_tweets['clean-tweet'].map(get_nouns)
ellen_tweets.shape
ellen_tweets = ellen_tweets[ellen_tweets['nouns'] != '']
tfidf_v = TfidfVectorizer(stop_words='english')
tfidf=tfidf_v.fit_transform(ellen_tweets['nouns'])
tfidf_feature_names=tfidf_v.get_feature_names()
no_topics=3
nmf=NMF(n_components=no_topics, random_state=1, alpha=0.1, l1_ratio=0.5, init='nndsvd')
lda=LatentDirichletAllocation(n_components=no_topics, max_iter=5, learning_method='online', learning_offset=50,random_state=0)
nmf_output = nmf.fit_transform(tfidf)
lda_output = lda.fit_transform(tfidf)
no_top_words = 20
display_topics(nmf, tfidf_feature_names, no_top_words)
display_topics(lda, tfidf_feature_names, no_top_words)
# ## Testing on Random User Data
df = pd.read_csv('datasets/kaggle-tweets-users150.csv')
df = df[['user', 'text']].rename(columns={'text': 'Tweet Content'})
# ### Random User 1
user1_df = df[df.user == 'SongoftheOss']
user1_model = TweetCategory(ovr_svc, tfidf_model, user1_df, ref)
user1_model.process_user_tweets()
top_categories = user1_model.predict_topics(0, 0.2)
print(top_categories)
user1_df = user1_model.predict_df
self_care = user1_df[(user1_df['probability'] >= 0.2) &(user1_df['predicted'] =='Self-care')]['tweet'].to_list()
food = user1_df[(user1_df['probability'] >= 0.2) &(user1_df['predicted'] =='Food')]['tweet'].to_list()
music = user1_df[(user1_df['probability'] >= 0.2) &(user1_df['predicted'] =='Music')]['tweet'].to_list()
print(self_care)
print(food)
print(music)
# ### Random User 2
user2_df = df[df.user == 'shanajaca']
user2_model = TweetCategory(ovr_svc, tfidf_model, user2_df, ref)
user2_model.process_user_tweets()
top_categories = user2_model.predict_topics(0, 0.2)
print(top_categories)
# User tweets from this dataset does not look good - it appears to be comments. I will try scraping Twitter to get real users tweets.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="aNNm3IN8jiEr"
# # BPR on MovieLens-100K
# + id="NJqvSp6glX16"
import os
import sys
import numpy as np
import pandas as pd
from math import ceil
from tqdm import trange
from subprocess import call
from itertools import islice
from sklearn.metrics import roc_auc_score
from sklearn.preprocessing import normalize
from sklearn.neighbors import NearestNeighbors
from scipy.sparse import csr_matrix, dok_matrix
import warnings
warnings.filterwarnings('ignore')
# + id="K5T23WD_jjx5"
file_dir = 'ml-100k'
file_path = os.path.join(file_dir, 'u.data')
if not os.path.isdir(file_dir):
call(['curl', '-O', 'http://files.grouplens.org/datasets/movielens/' + file_dir + '.zip'])
call(['unzip', file_dir + '.zip'])
# + colab={"base_uri": "https://localhost:8080/", "height": 241} id="KY-En9ualQFN" executionInfo={"status": "ok", "timestamp": 1633087296397, "user_tz": -330, "elapsed": 508, "user": {"displayName": "Sparsh Agarwal", "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64", "userId": "13037694610922482904"}} outputId="c94cb4de-5dab-4031-e05e-7104b6d13b3e"
# we will not be using the timestamp column
names = ['user_id', 'item_id', 'rating', 'timestamp']
df = pd.read_csv(file_path, sep = '\t', names = names)
print('data dimension: \n', df.shape)
df.head()
# + [markdown] id="QRd_PdpKlMq3"
# Because BPR assumes binary implicit feedback (meaing there's only positive and negative items), here we'll assume that an item is positive only if he/she gave the item a ratings above 3 (feel free to experiment and change the threshold). The next few code chunks, creates the sparse interaction matrix and split into train and test set.
# + id="MROU2tKnlKqp"
def create_matrix(data, users_col, items_col, ratings_col, threshold = None):
"""
creates the sparse user-item interaction matrix,
if the data is not in the format where the interaction only
contains the positive items (indicated by 1), then use the
threshold parameter to determine which items are considered positive
Parameters
----------
data : DataFrame
implicit rating data
users_col : str
user column name
items_col : str
item column name
ratings_col : str
implicit rating column name
threshold : int, default None
threshold to determine whether the user-item pair is
a positive feedback
Returns
-------
ratings : scipy sparse csr_matrix, shape [n_users, n_items]
user/item ratings matrix
data : DataFrame
implict rating data that retains only the positive feedback
(if specified to do so)
"""
if threshold is not None:
data = data[data[ratings_col] >= threshold]
data[ratings_col] = 1
for col in (items_col, users_col, ratings_col):
data[col] = data[col].astype('category')
ratings = csr_matrix((data[ratings_col],
(data[users_col].cat.codes, data[items_col].cat.codes)))
ratings.eliminate_zeros()
return ratings, data
# + id="Sgj5GOoslJPk"
items_col = 'item_id'
users_col = 'user_id'
ratings_col = 'rating'
threshold = 3
# + colab={"base_uri": "https://localhost:8080/"} id="qQm5nF6BlH3F" executionInfo={"status": "ok", "timestamp": 1633087299718, "user_tz": -330, "elapsed": 14, "user": {"displayName": "Sparsh Agarwal", "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64", "userId": "13037694610922482904"}} outputId="cd929724-964d-429c-8e07-40183866877c"
X, df = create_matrix(df, users_col, items_col, ratings_col, threshold)
X
# + id="dsSRZ3H2lF4y"
def create_train_test(ratings, test_size = 0.2, seed = 1234):
"""
split the user-item interactions matrix into train and test set
by removing some of the interactions from every user and pretend
that we never seen them
Parameters
----------
ratings : scipy sparse csr_matrix, shape [n_users, n_items]
The user-item interactions matrix
test_size : float between 0.0 and 1.0, default 0.2
Proportion of the user-item interactions for each user
in the dataset to move to the test set; e.g. if set to 0.2
and a user has 10 interactions, then 2 will be moved to the
test set
seed : int, default 1234
Seed for reproducible random splitting the
data into train/test set
Returns
-------
train : scipy sparse csr_matrix, shape [n_users, n_items]
Training set
test : scipy sparse csr_matrix, shape [n_users, n_items]
Test set
"""
assert test_size < 1.0 and test_size > 0.0
# Dictionary Of Keys based sparse matrix is more efficient
# for constructing sparse matrices incrementally compared with csr_matrix
train = ratings.copy().todok()
test = dok_matrix(train.shape)
# for all the users assign randomly chosen interactions
# to the test and assign those interactions to zero in the training;
# when computing the interactions to go into the test set,
# remember to round up the numbers (e.g. a user has 4 ratings, if the
# test_size is 0.2, then 0.8 ratings will go to test, thus we need to
# round up to ensure the test set gets at least 1 rating)
rstate = np.random.RandomState(seed)
for u in range(ratings.shape[0]):
split_index = ratings[u].indices
n_splits = ceil(test_size * split_index.shape[0])
test_index = rstate.choice(split_index, size = n_splits, replace = False)
test[u, test_index] = ratings[u, test_index]
train[u, test_index] = 0
train, test = train.tocsr(), test.tocsr()
return train, test
# + colab={"base_uri": "https://localhost:8080/"} id="pIzQWiFElEGq" executionInfo={"status": "ok", "timestamp": 1633087304877, "user_tz": -330, "elapsed": 498, "user": {"displayName": "Sparsh Agarwal", "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64", "userId": "13037694610922482904"}} outputId="522898e3-10b5-4123-c49e-7b5d0f8b952e"
X_train, X_test = create_train_test(X, test_size = 0.2, seed = 1234)
X_train
# + [markdown] id="1Wra9k39k7xF"
# The following section provides a implementation of the algorithm from scratch.
# + id="88aLcnS4k9Py"
class BPR:
"""
Bayesian Personalized Ranking (BPR) for implicit feedback data
Parameters
----------
learning_rate : float, default 0.01
learning rate for gradient descent
n_factors : int, default 20
Number/dimension of user and item latent factors
n_iters : int, default 15
Number of iterations to train the algorithm
batch_size : int, default 1000
batch size for batch gradient descent, the original paper
uses stochastic gradient descent (i.e., batch size of 1),
but this can make the training unstable (very sensitive to
learning rate)
reg : int, default 0.01
Regularization term for the user and item latent factors
seed : int, default 1234
Seed for the randomly initialized user, item latent factors
verbose : bool, default True
Whether to print progress bar while training
Attributes
----------
user_factors : 2d ndarray, shape [n_users, n_factors]
User latent factors learnt
item_factors : 2d ndarray, shape [n_items, n_factors]
Item latent factors learnt
References
----------
S. Rendle, C. Freudenthaler, Z. Gantner, L. Schmidt-Thieme
Bayesian Personalized Ranking from Implicit Feedback
- https://arxiv.org/abs/1205.2618
"""
def __init__(self, learning_rate = 0.01, n_factors = 15, n_iters = 10,
batch_size = 1000, reg = 0.01, seed = 1234, verbose = True):
self.reg = reg
self.seed = seed
self.verbose = verbose
self.n_iters = n_iters
self.n_factors = n_factors
self.batch_size = batch_size
self.learning_rate = learning_rate
# to avoid re-computation at predict
self._prediction = None
def fit(self, ratings):
"""
Parameters
----------
ratings : scipy sparse csr_matrix, shape [n_users, n_items]
sparse matrix of user-item interactions
"""
indptr = ratings.indptr
indices = ratings.indices
n_users, n_items = ratings.shape
# ensure batch size makes sense, since the algorithm involves
# for each step randomly sample a user, thus the batch size
# should be smaller than the total number of users or else
# we would be sampling the user with replacement
batch_size = self.batch_size
if n_users < batch_size:
batch_size = n_users
sys.stderr.write('WARNING: Batch size is greater than number of users,'
'switching to a batch size of {}\n'.format(n_users))
batch_iters = n_users // batch_size
# initialize random weights
rstate = np.random.RandomState(self.seed)
self.user_factors = rstate.normal(size = (n_users, self.n_factors))
self.item_factors = rstate.normal(size = (n_items, self.n_factors))
# progress bar for training iteration if verbose is turned on
loop = range(self.n_iters)
if self.verbose:
loop = trange(self.n_iters, desc = self.__class__.__name__)
for _ in loop:
for _ in range(batch_iters):
sampled = self._sample(n_users, n_items, indices, indptr)
sampled_users, sampled_pos_items, sampled_neg_items = sampled
self._update(sampled_users, sampled_pos_items, sampled_neg_items)
return self
def _sample(self, n_users, n_items, indices, indptr):
"""sample batches of random triplets u, i, j"""
sampled_pos_items = np.zeros(self.batch_size, dtype = np.int)
sampled_neg_items = np.zeros(self.batch_size, dtype = np.int)
sampled_users = np.random.choice(
n_users, size = self.batch_size, replace = False)
for idx, user in enumerate(sampled_users):
pos_items = indices[indptr[user]:indptr[user + 1]]
pos_item = np.random.choice(pos_items)
neg_item = np.random.choice(n_items)
while neg_item in pos_items:
neg_item = np.random.choice(n_items)
sampled_pos_items[idx] = pos_item
sampled_neg_items[idx] = neg_item
return sampled_users, sampled_pos_items, sampled_neg_items
def _update(self, u, i, j):
"""
update according to the bootstrapped user u,
positive item i and negative item j
"""
user_u = self.user_factors[u]
item_i = self.item_factors[i]
item_j = self.item_factors[j]
# decompose the estimator, compute the difference between
# the score of the positive items and negative items; a
# naive implementation might look like the following:
# r_ui = np.diag(user_u.dot(item_i.T))
# r_uj = np.diag(user_u.dot(item_j.T))
# r_uij = r_ui - r_uj
# however, we can do better, so
# for batch dot product, instead of doing the dot product
# then only extract the diagonal element (which is the value
# of that current batch), we perform a hadamard product,
# i.e. matrix element-wise product then do a sum along the column will
# be more efficient since it's less operations
# http://people.revoledu.com/kardi/tutorial/LinearAlgebra/HadamardProduct.html
# r_ui = np.sum(user_u * item_i, axis = 1)
#
# then we can achieve another speedup by doing the difference
# on the positive and negative item up front instead of computing
# r_ui and r_uj separately, these two idea will speed up the operations
# from 1:14 down to 0.36
r_uij = np.sum(user_u * (item_i - item_j), axis = 1)
sigmoid = np.exp(-r_uij) / (1.0 + np.exp(-r_uij))
# repeat the 1 dimension sigmoid n_factors times so
# the dimension will match when doing the update
sigmoid_tiled = np.tile(sigmoid, (self.n_factors, 1)).T
# update using gradient descent
grad_u = sigmoid_tiled * (item_j - item_i) + self.reg * user_u
grad_i = sigmoid_tiled * -user_u + self.reg * item_i
grad_j = sigmoid_tiled * user_u + self.reg * item_j
self.user_factors[u] -= self.learning_rate * grad_u
self.item_factors[i] -= self.learning_rate * grad_i
self.item_factors[j] -= self.learning_rate * grad_j
return self
def predict(self):
"""
Obtain the predicted ratings for every users and items
by doing a dot product of the learnt user and item vectors.
The result will be cached to avoid re-computing it every time
we call predict, thus there will only be an overhead the first
time we call it. Note, ideally you probably don't need to compute
this as it returns a dense matrix and may take up huge amounts of
memory for large datasets
"""
if self._prediction is None:
self._prediction = self.user_factors.dot(self.item_factors.T)
return self._prediction
def _predict_user(self, user):
"""
returns the predicted ratings for the specified user,
this is mainly used in computing evaluation metric
"""
user_pred = self.user_factors[user].dot(self.item_factors.T)
return user_pred
def recommend(self, ratings, N = 5):
"""
Returns the top N ranked items for given user id,
excluding the ones that the user already liked
Parameters
----------
ratings : scipy sparse csr_matrix, shape [n_users, n_items]
sparse matrix of user-item interactions
N : int, default 5
top-N similar items' N
Returns
-------
recommendation : 2d ndarray, shape [number of users, N]
each row is the top-N ranked item for each query user
"""
n_users = ratings.shape[0]
recommendation = np.zeros((n_users, N), dtype = np.uint32)
for user in range(n_users):
top_n = self._recommend_user(ratings, user, N)
recommendation[user] = top_n
return recommendation
def _recommend_user(self, ratings, user, N):
"""the top-N ranked items for a given user"""
scores = self._predict_user(user)
# compute the top N items, removing the items that the user already liked
# from the result and ensure that we don't get out of bounds error when
# we ask for more recommendations than that are available
liked = set(ratings[user].indices)
count = N + len(liked)
if count < scores.shape[0]:
# when trying to obtain the top-N indices from the score,
# using argpartition to retrieve the top-N indices in
# unsorted order and then sort them will be faster than doing
# straight up argort on the entire score
# http://stackoverflow.com/questions/42184499/cannot-understand-numpy-argpartition-output
ids = np.argpartition(scores, -count)[-count:]
best_ids = np.argsort(scores[ids])[::-1]
best = ids[best_ids]
else:
best = np.argsort(scores)[::-1]
top_n = list(islice((rec for rec in best if rec not in liked), N))
return top_n
def get_similar_items(self, N = 5, item_ids = None):
"""
return the top N similar items for itemid, where
cosine distance is used as the distance metric
Parameters
----------
N : int, default 5
top-N similar items' N
item_ids : 1d iterator, e.g. list or numpy array, default None
the item ids that we wish to find the similar items
of, the default None will compute the similar items
for all the items
Returns
-------
similar_items : 2d ndarray, shape [number of query item_ids, N]
each row is the top-N most similar item id for each
query item id
"""
# cosine distance is proportional to normalized euclidean distance,
# thus we normalize the item vectors and use euclidean metric so
# we can use the more efficient kd-tree for nearest neighbor search;
# also the item will always to nearest to itself, so we add 1 to
# get an additional nearest item and remove itself at the end
normed_factors = normalize(self.item_factors)
knn = NearestNeighbors(n_neighbors = N + 1, metric = 'euclidean')
knn.fit(normed_factors)
# returns a distance, index tuple,
# we don't actually need the distance
if item_ids is not None:
normed_factors = normed_factors[item_ids]
_, items = knn.kneighbors(normed_factors)
similar_items = items[:, 1:].astype(np.uint32)
return similar_items
# + colab={"base_uri": "https://localhost:8080/"} id="zdd2n-33lBEH" executionInfo={"status": "ok", "timestamp": 1633087316122, "user_tz": -330, "elapsed": 3142, "user": {"displayName": "Sparsh Agarwal", "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64", "userId": "13037694610922482904"}} outputId="60dafcae-018f-4f81-cc99-43d86b8a3a82"
# parameters were randomly chosen
bpr_params = {'reg': 0.01,
'learning_rate': 0.1,
'n_iters': 160,
'n_factors': 15,
'batch_size': 100}
bpr = BPR(**bpr_params)
bpr.fit(X_train)
# + [markdown] id="8vZzKWgykx8v"
# ### Evaluation
# In recommender systems, we are often interested in how well the method can rank a given set of items. And to do that we'll use AUC (Area Under ROC Curve as our evaluation metric. The best possible value that the AUC evaluation metric can take is 1, and any non-random ranking that makes sense would have an AUC > 0.5. An intuitive explanation of AUC is it specifies the probability that when we draw two examples at random, their predicted pairwise ranking is correct. The following documentation has a more detailed discussion on AUC in case you're not familiar with it.
# + colab={"base_uri": "https://localhost:8080/"} id="9Orl71G1kzig" executionInfo={"status": "ok", "timestamp": 1633087326342, "user_tz": -330, "elapsed": 2914, "user": {"displayName": "Sparsh Agarwal", "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64", "userId": "13037694610922482904"}} outputId="60adbc62-cbda-4dd9-dc1e-947910e87330"
def auc_score(model, ratings):
"""
computes area under the ROC curve (AUC).
The full name should probably be mean
auc score as it is computing the auc
for every user's prediction and actual
interaction and taking the average for
all users
Parameters
----------
model : BPR instance
Trained BPR model
ratings : scipy sparse csr_matrix, shape [n_users, n_items]
sparse matrix of user-item interactions
Returns
-------
auc : float 0.0 ~ 1.0
"""
auc = 0.0
n_users, n_items = ratings.shape
for user, row in enumerate(ratings):
y_pred = model._predict_user(user)
y_true = np.zeros(n_items)
y_true[row.indices] = 1
auc += roc_auc_score(y_true, y_pred)
auc /= n_users
return auc
print(auc_score(bpr, X_train))
print(auc_score(bpr, X_test))
# + [markdown] id="MYMYeQEIkmaN"
# ### Item Recommendations
# Given the trained model, we can get the most similar items by using the get_similar_items method, we can specify the number of most similar items by specifying the N argument. And this can be seen as the people who like/buy this also like/buy this functionality, since it's recommending similar items for a given item.
# + colab={"base_uri": "https://localhost:8080/"} id="vIR5p0qMkm_Y" executionInfo={"status": "ok", "timestamp": 1633087331598, "user_tz": -330, "elapsed": 699, "user": {"displayName": "Sparsh Agarwal", "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64", "userId": "13037694610922482904"}} outputId="5abd8860-4626-47df-c0c4-7c6b3afccfa8"
bpr.get_similar_items(N = 5)
# + colab={"base_uri": "https://localhost:8080/"} id="sWbtfgAmkp3A" executionInfo={"status": "ok", "timestamp": 1633087334737, "user_tz": -330, "elapsed": 9, "user": {"displayName": "Sparsh Agarwal", "photoUrl": "https://lh3.googleusercontent.com/a/default-user=s64", "userId": "13037694610922482904"}} outputId="1d3932ec-723d-4e2f-a351-c90db2eef0a9"
bpr.recommend(X_train, N = 5)
# + [markdown] id="BUGKT-vClyIg"
# For these two methods, we can go one step further and look-up the actual item for these indices to see if they make intuitive sense. If we wish to do this, the movielens dataset has a u.item file that contains metadata about the movie.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [Root]
# language: python
# name: Python [Root]
# ---
# # Lab 1: Exploring NFL Play-By-Play Data
# ## Data Loading and Preprocessing
# To begin, we load the data into a Pandas data frame from a csv file.
# +
import pandas as pd
import numpy as np
df = pd.read_csv('data/data.csv') # read in the csv file
# -
# Let's take a cursory glance at the data to see what we're working with.
df.head()
# There's a lot of data that we don't care about. For example, 'PassAttempt' is a binary attribute, but there's also an attribute called 'PlayType' which is set to 'Pass' for a passing play.
#
# We define a list of the columns which we're not interested in, and then we delete them
# +
columns_to_delete = ['Unnamed: 0', 'Date', 'time', 'TimeUnder',
'PosTeamScore', 'PassAttempt', 'RushAttempt',
'DefTeamScore', 'Season', 'PlayAttempted']
#Iterate through and delete the columns we don't want
for col in columns_to_delete:
if col in df:
del df[col]
# -
# We can then grab a list of the remaining column names
df.columns
# Temporary simple data replacement so that we can cast to integers (instead of objects)
df.info()
df = df.replace(to_replace=np.nan,value=-1)
# At this point, lots of things are encoded as objects, or with excesively large data types
df.info()
# We define four lists based on the types of features we're using.
# Binary features are separated from the other categorical features so that they can be stored in less space
# +
continuous_features = ['TimeSecs', 'PlayTimeDiff', 'yrdln', 'yrdline100',
'ydstogo', 'ydsnet', 'Yards.Gained', 'Penalty.Yards',
'ScoreDiff', 'AbsScoreDiff']
ordinal_features = ['Drive', 'qtr', 'down']
binary_features = ['GoalToGo', 'FirstDown','sp', 'Touchdown', 'Safety', 'Fumble']
categorical_features = df.columns.difference(continuous_features).difference(ordinal_features)
# -
# We then cast all of the columns to the appropriate underlying data types
df[continuous_features] = df[continuous_features].astype(np.float64)
df[ordinal_features] = df[ordinal_features].astype(np.int64)
df[binary_features] = df[binary_features].astype(np.int8)
# THIS IS SOME MORE REFORMATTING SHIT I'M DOING FOR NOW. PROLLY GONNA KEEP IT
df['PassOutcome'].replace(['Complete', 'Incomplete Pass'], [1, 0], inplace=True)
df = df[df["PlayType"] != 'Quarter End']
df = df[df["PlayType"] != 'Two Minute Warning']
df = df[df["PlayType"] != 'End of Game']
# Now all of the objects are encoded the way we'd like them to be
df.info()
# Now we can start to take a look at what's in each of our columns
df.describe()
# +
import matplotlib.pyplot as plt
import warnings
warnings.simplefilter('ignore', DeprecationWarning)
#Embed figures in the Jupyter Notebook
# %matplotlib inline
#Use GGPlot style for matplotlib
plt.style.use('ggplot')
# -
pass_plays = df[df['PlayType'] == "Pass"]
pass_plays_grouped = pass_plays.groupby(by=['Passer'])
# Look at the number of yards gained by a FirstDown
# +
first_downs_grouped = df.groupby(by=['FirstDown'])
print(first_downs_grouped['Yards.Gained'].count())
print("-----------------------------")
print(first_downs_grouped['Yards.Gained'].sum())
print("-----------------------------")
print(first_downs_grouped['Yards.Gained'].sum()/first_downs_grouped['Yards.Gained'].count())
# -
# Group by play type
plays_grouped = df.groupby(by=['PlayType'])
print(plays_grouped['Yards.Gained'].count())
print("-----------------------------")
print(plays_grouped['Yards.Gained'].sum())
print("-----------------------------")
print(plays_grouped['Yards.Gained'].sum()/plays_grouped['Yards.Gained'].count())
# We can eliminate combos who didn't have at least 10 receptions together, and then re-sample the data. This will remove noise from QB-receiver combos who have very high or low completion rates because they've played very little together.
size = 10
corr = df.corr()
fig, ax = plt.subplots(figsize=(size, size))
ax.matshow(corr)
plt.xticks(range(len(corr.columns)), corr.columns);
for tick in ax.get_xticklabels():
tick.set_rotation(90)
plt.yticks(range(len(corr.columns)), corr.columns);
# We can also extract the highest-completion percentage combos.
# Here we take the top-10 most reliable QB-receiver pairs.
import seaborn as sns
# +
# df_dropped = df.dropna()
# df_dropped.info()
selected_types = df.select_dtypes(exclude=["object"])
useful_attributes = df[['FieldGoalDistance','ydstogo']]
print(useful_attributes)
# -
sns.heatmap(corr)
cluster_corr = sns.clustermap(corr)
plt.setp(cluster_corr.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
# plt.xticks(rotation=90)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Demo SequenceActivity
# The sequence activity calls all activities which are specified as sub processes.
# +
import datetime, time
import simpy
import pandas as pd
import openclsim.core as core
import openclsim.model as model
import openclsim.plot as plot
# setup environment
simulation_start = 0
my_env = simpy.Environment(initial_time=simulation_start)
registry = {}
# -
# ## Definition of the subprocesses used in the seqeunce activity
# The sequence activity executes three basic activities in a sequence. Since the individual basic activities are executed one after the other, it is necessary to postpone the initialization of the initialization of these activities. This is done using the **postpone_start** parameter.
#
# To ensure that all logging of the basic activities are available in a single log, additional logging is configured to an reporting activity.
# +
reporting_activity = model.BasicActivity(
env=my_env,
name="Reporting activity",
registry=registry,
duration=0,
)
sub_processes = [
model.BasicActivity(
env=my_env,
name="Basic activity1",
registry=registry,
duration=14,
additional_logs=[reporting_activity],
),
model.BasicActivity(
env=my_env,
name="Basic activity2",
registry=registry,
duration=5,
additional_logs=[reporting_activity],
),
model.BasicActivity(
env=my_env,
name="Basic activity3",
registry=registry,
duration=220,
additional_logs=[reporting_activity],
),
]
# -
# ## Definition of seqeunce activity
activity = model.SequentialActivity(
env=my_env,
name="Sequential process",
registry=registry,
sub_processes=sub_processes,
)
model.register_processes([activity])
my_env.run()
plot.vessel_planning([*sub_processes, activity])
display(plot.get_log_dataframe(reporting_activity, [*sub_processes, activity, reporting_activity]))
for act in [*sub_processes, activity]:
display(plot.get_log_dataframe(act, [*sub_processes, activity, reporting_activity]))
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# <center>
# <img src="logo.png" height="900">
# </center>
#
#
# # Анализируем чеки
#
# В этом задании мы будем работать с покупками и чеками. Смотреть за корреляциями в покупках довольно полезно.
#
# > В 1992 году группа по консалтингу в области ритейла компании Teradata под руководством Томаса Блишока провела исследование 1.2 миллиона транзакций в 25 магазинах для ритейлера Osco Drug (Drug Store — формат разнокалиберных магазинов у дома). После анализа всех этих транзакций самым сильным правилом получилось «Между 17:00 и 19:00 чаще всего пиво и подгузники покупают вместе». К сожалению, такое правило показалось руководству Osco Drug настолько контринтуитивным, что ставить подгузники на полках рядом с пивом они не стали. Хотя объяснение паре пиво-подгузники вполне себе нашлось: когда оба члена молодой семьи возвращались с работы домой (как раз часам к 5 вечера), жены обычно отправляли мужей за подгузниками в ближайший магазин. И мужья, не долго думая, совмещали приятное с полезным — покупали подгузники по заданию жены и пиво для собственного вечернего времяпрепровождения.
#
# Для работы будем использовать датасет о продуктовых корзинах: https://www.kaggle.com/heeraldedhia/groceries-dataset
# +
import numpy as np
import pandas as pd
import scipy.stats as sts
import matplotlib.pyplot as plt
import seaborn as sns
plt.style.use('ggplot') # стиль для графиков
# %matplotlib inline
# -
# Подружаем данные и смотрим как они выглядят.
df = pd.read_csv('groceries.csv', sep=',')
df.columns = ['id', 'fielddate', 'product']
print(df.shape)
df.head()
# ## 1. Корреляции
#
# Для начала поработаем с корреляциями в данных.
#
# __а)__ Какой товар покупался чаще всего? Сохраните название этого товара в переменную `product_name`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "0b37d486e7075ec828881d3045268b4d", "grade": false, "grade_id": "cell-9d268bdaaa451d51", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
product_name = df['product'].mode().values[0]
# your code here
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "153389c55c6243d7b8897ca0e33be5a5", "grade": true, "grade_id": "cell-2fd1cfdcf5400ee3", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false}
# проверка, что задание решено корректно
assert len(product_name) == 10
# Аналогичные тесты скрыты от вас
# -
# __б)__ Сколько всего уникальных заказов было сделано? Сохраните число заказов в переменную `n_cnt`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "b627f3336f6abc1f2a76b26116021af2", "grade": false, "grade_id": "cell-4c3ce54e9c52ae14", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
n_cnt = len(df['id'].unique())
n_cnt
# your code here
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "f93cfd87b43b743e88a4a21d5a773f5e", "grade": true, "grade_id": "cell-608432c41bdcd71d", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false}
# проверка, что задание решено корректно
assert n_cnt > 3800
assert n_cnt < 4000
# Аналогичные тесты скрыты от вас
# -
# В таблице выше в каждой строке записана информация о покупке конкретного товара. Давайте сделаем табличку размера "число товаров" на "число покупок", чтобы понимать какие товары покупались вместе, а какие нет.
#
# > Обратите внимание, то здесь задание немного упрощено. Вообще говоря, нам нужно делать агрегацию по паре `fielddate, id`, если мы хотим изучать чеки по-честному. Но мы делаем её только по `id` для того, чтобы не усложнять задание. В качестве необязательного дополнения вы можете после сдачи задания переделать код так, чтобы дата тоже учитывалась при расчётах.
# +
sparse_sales = pd.pivot_table(df,
values='fielddate',
index='id',
columns='product',
fill_value=0, aggfunc='count')
sparse_sales.head()
# -
# В нашей матрице огромное число нулей. Обычно такие матрицы называют разряжеными. Мы занимаем нулями кучу свободной памяти, которую мы могли бы не занимать, если бы хранили данные [в ином виде.](https://cmdlinetips.com/2018/03/sparse-matrices-in-python-with-scipy/)
# __в)__ Постройте матрицу корреляций Пирсона. Для этого используйте метод таблицы `.corr`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "88338d4e2f060abd7fb2053c0ffc39dd", "grade": false, "grade_id": "cell-a8f15b8ba3a946c8", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
sales_correlation = sparse_sales.corr()
sales_correlation
# your code here
# -
# Какие продукты сильнее всего коррелируют с яйцами, `domestic eggs` (их чаще всего покупают вместе)? Сохраните название самого скоррелированного продукта в переменную `top_1`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "0bd0243dc6204b2172419735648495f3", "grade": false, "grade_id": "cell-cf20442762e0f104", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
top_1 = sales_correlation['domestic eggs'].sort_values().index[-2]
top_1
# your code here
# -
# Какие продукты "мешают" купить яйца, то есть отрицательно коррелируют с их покупкой? Сохраните название продукта с самой большой отрицательной корреляцией в переменную `bottom_1`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "b1b4d2eb18aa5e07ae9ff6c8263cf038", "grade": false, "grade_id": "cell-fbd202e1529e31c7", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
bottom_1 = sales_correlation['domestic eggs'].sort_values().index[0]
bottom_1
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "6ac2ce2c786529bbf15bc7a6d8e5b419", "grade": true, "grade_id": "cell-d070d4a1a7bde720", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false}
# проверка, что задание решено корректно
assert len(bottom_1) == 8
assert len(top_1) == 12
# Аналогичные тесты скрыты от вас
# -
# Напишите код, который выводит самые коррелируемые товары для случайного продукта из списка `unique_products`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "d9963e0690e8f979766ae92f7c9e1637", "grade": false, "grade_id": "cell-50a7be49564df467", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
unique_products = df['product'].unique()
random_lol = np.random.choice(unique_products)
sales_correlation[random_lol].sort_values(ascending=False)
# your code here
# -
# __г)__ Какие два продукта коррелируют сильнее всего? Положите их название в лист `answer`
# + deletable=false nbgrader={"cell_type": "code", "checksum": "b17da2e38d71902e9d6b14d8b5d11380", "grade": false, "grade_id": "cell-dd462f4db3d9a2f7", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
answer = ['preservation products','soups']
sales_correlation.unstack().sort_values(ascending=False)[150:170]
# your code here
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "6ff9da58bc1861cd17f35b979e3d3e41", "grade": true, "grade_id": "cell-894ff9bec07f24e0", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false}
# проверка, что задание решено корректно
assert 'soups' in answer
# Аналогичные тесты скрыты от вас
# -
# Конечно же, корреляция — это [не единственный способ искать](https://habr.com/ru/company/ods/blog/353502/) между покупками ассоциативные правила.
# ## 2. Зависимость.
#
# В лекции мы с вами сказали, что события $A$ и $B$ называются независимыми, если $P(AB) = P(A)\cdot P(B)$. Отталкиваясь от этого определения, можно ввести другую характеристику, которая показывает, насколько продукты зависят друг от друга, а именно __поддержку (lift).__
#
# $$
# lift = \frac{P(AB)}{P(A)\cdot P(B)}
# $$
# Эта метрика описывает отношение зависимости товаров к их независимости. Если оказалось, что `lift = 1`, это означает, что покупка товара $A$ не зависит от покупки товара $B$. Если `lift > 1`, то это означает, что вероятность встретить оба товара в чеке, $P(AB)$ высокая, то есть товары покупают вместе. Если `lift < 1`, это означает, что товары, наоборот, очень часто покупают по-отдельности.
# __д)__ Посчитайте значение нашей метрики для яиц и молока (`'whole milk', 'domestic eggs'`). Запишите получившиеся значение метрики в переменную `answer`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "3651c09339b2db8ee9882d3950ed3b10", "grade": false, "grade_id": "cell-db191a336be19f97", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
PAB = len(sparse_sales[(sparse_sales['whole milk']>=1) & (sparse_sales['domestic eggs']>=1)]) /sparse_sales.shape[0]
PA = len(sparse_sales[(sparse_sales['whole milk']>=1)]) /sparse_sales.shape[0]
PB = len(sparse_sales[(sparse_sales['domestic eggs']>=1)]) /sparse_sales.shape[0]
answer = PAB / (PA * PB)
# your code here
answer
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "ae6b5fdfedb6956db845d780ce9bfbf0", "grade": true, "grade_id": "cell-c2f789696293a0b3", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false}
# проверка, что задание решено корректно
assert answer < 3
assert answer > 1
# Аналогичные тесты скрыты от вас
# -
# __е)__ Посчитайте значение метрики для всех пар продуктов из датасета. Сохраните значения в словарик `dict`. В качестве ключа используете кортеж из пары продуктов. Чтобы удобнее было перебрать все сочетания, используйте `combinations` из модуля `itertools`.
#
# Чтобы при подсчётах не возникало деления на ноль, добавьте к знаменателю маленькое число, например `1e-10`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "26f315f8a90daedcda97ffc328155445", "grade": false, "grade_id": "cell-e512719bd3dbbd34", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
# your code here
# -
import itertools as it
comb = list(it.combinations(unique_products, 2))
test = []
# food_lift= []
# for i in range(len(comb)):
# t = len(sparse_sales[(sparse_sales[comb[i][0]]==True)&(sparse_sales[comb[i][1]]==True)])
# if (t == 0) and food_lift[comb[i]] > 0:
# # print(comb[i])
# # break
# if t != 0:
# test.append(comb[i])
comb[i]
sparse_sales[(sparse_sales[comb[i][0]]==True)&(sparse_sales[comb[i][1]]==True)]
# +
# food_lift[('whole milk', 'cream')]
# -
(sparse_sales [['whole milk', 'cream']] >= 1).all(axis=1).sum()
ab = (sparse_sales [['whole milk', 'cream']] >= 1).all(axis=1).mean()
a = (sparse_sales ['whole milk'] >= 1).mean()
b = (sparse_sales ['cream'] >= 1).mean()
answer = ab/(a*b)
answer
len(set(test))
# Сколько пар продуктов покупали вместе хотя бы раз? Запишите ответ в переменную `answer`.
# + deletable=false nbgrader={"cell_type": "code", "checksum": "fb58676df1e4d46a7fd690855903dca4", "grade": false, "grade_id": "cell-097e70120aa5a596", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
answer =15
# your code here
# -
# Для какой пары продуктов метрика $lift$ оказалась самой большой?
# + deletable=false nbgrader={"cell_type": "code", "checksum": "3935f2223dddf3a9658a90034e2ebd5d", "grade": false, "grade_id": "cell-e0e772420c99a1f4", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
# your code here
# -
# Сколько раз эти продукты встретились в выборке? Как думаете адеватно ли делать выводы по такому объёму данных?
# + deletable=false nbgrader={"cell_type": "code", "checksum": "dc2e17f19344df8a8e09d989c31e436b", "grade": false, "grade_id": "cell-cfbf5b5deb321f36", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
# your code here
# -
# Для какой пары продуктов метрика оказывается самой маленькой?
# + deletable=false nbgrader={"cell_type": "code", "checksum": "a4a911333c146c4d9ec09e8f51a5fb6c", "grade": false, "grade_id": "cell-0c88c82cc7bdef09", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
# your code here
answer = 9500
# + deletable=false editable=false nbgrader={"cell_type": "code", "checksum": "c15571d658306ab43839bcf4d8e42bae", "grade": true, "grade_id": "cell-b7f41317d840457e", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false}
# проверка, что задание решено корректно
assert answer < 10000
assert answer > 9000
# Аналогичные тесты скрыты от вас
# -
# ## 3. Неоцениваемые задания
#
# Выше мы увидели, что некоторые продукты встречаются в выборке очень редко. Понятное дело, что по ним у нас не получится построить хорошее ассоциативное правило. Попробуйте повторить расчёт той же метрики, но с условием что продукт покупали больше 10 раз. Изучите самые покупаемые вместе продукты и самые непокупаемые вместе продукты. Насколько сильно список отличается от полученного в предыдущем задании?
# + deletable=false nbgrader={"cell_type": "code", "checksum": "99e685544038e446e2d67bd1cd4f6a3c", "grade": false, "grade_id": "cell-aa30f3933e22e20d", "locked": false, "schema_version": 3, "solution": true, "task": false}
### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════ bzzzzzzzzzz
# will the code be with you
# your code here
# -
# Иногда в чеках пытаются искать __продукты-якоря.__ То есть продукты, которые являются основными. Например: айфон - основной продукт, наушники и чехол - дополнения к нему. Подумайте как можно попытаться найти такие продукты на основе простых метрик, основанных на подсчёте условных вероятностей.
# <center>
# <img src="https://pp.userapi.com/c638028/v638028181/52e5e/1X-dkzNN1hk.jpg" width="400">
# </center>
#
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
pal = [(39/255,95/255,153/255),(80/255,176/255,220/255),
(237/255,244/255,248/255),
(146/255,144/255,142/255),
(78/255,78/255,80/255),
(235/255,154/255,88/255),(87/255,126/255,130/255)]
# imports
from statannot import add_stat_annotation
from scipy.stats import chi2
import statsmodels.stats.multitest as mt
import sys
from matplotlib import rcParams
sys.path.append("/Users/rcarlson/Documents/GitHub/lasagna3/snakes")
from ops.imports_ipython import *
from ops.firedove_barplots_v2 import *
import snf
# +
## IRF3 translocation upon SeV stimulation
df = pd.read_hdf('m120.hdf')
df.gene = df.gene.astype('category')
sorter = ['nontargeting','DDX58','MAVS','ATP13A1','CAPN15','ATP2B1','MAU2','MED16','MED24',
'TADA2B']
df.gene.cat.set_categories(sorter, inplace=True)
df = df.sort_values(["gene"])
df.gene = df.gene.astype('string')
aucs, grped = produce_barplot_general(df, df_name = 'm120', pshow = False,
genes = ['ATP13A1','ATP2B1','CAPN15','MAU2','MED16','MED24','TADA2B','DDX58','MAVS','nontargeting'],
gate = '100 < i <1380 & 100 < j < 1380 & area_nuclear <= 350 & dapi_median_nuclear < 50000 ',
replist = [1,2,3,4], nbins=50,
feature='dapi_gfp_corr_nuclear', pal = 'green', range_vals = (-1,1),
alpha=.05)
##
# +
## RIG-I induction upon SeV stimulation
df = pd.read_hdf('m136.hdf')
df.gene = df.gene.astype('category')
sorter = ['nontargeting','DDX58','MAVS','ATP13A1','CAPN15','ATP2B1','MAU2','MED16','MED24',
'TADA2B']
df.gene.cat.set_categories(sorter, inplace=True)
df = df.sort_values(["gene"])
df.gene = df.gene.astype('string')
aucs, grped = produce_barplot_general(df, df_name = 'm136', pshow = False,
genes = df.gene,
gate = '100 < i <1380 & 100 < j < 1380 & area < 3000 & channel_cell_median < 50000',
replist = [1,2,3,4], nbins=50,
feature='channel_cell_median', pal = 'red', plot_nt = True, range_vals = (500, 7000),
alpha=.05, pval_sort = False)
# +
## IRF3 translocation upon SeV stimulation in U937 cells
df = pd.read_hdf('m105.hdf')
df.gene = df.gene.astype('category')
sorter = ['nontargeting','DDX58','MAVS','ATP13A1','CAPN15','ATP2B1','MAU2','MED16','MED24',
'TADA2B']
df.gene.cat.set_categories(sorter, inplace=True)
df = df.sort_values(["gene"])
df.gene = df.gene.astype('string')
aucs, grped = produce_barplot_general(df, df_name = 'm105', pshow = False, genes = pd.unique(df.gene),
gate = '100 < i < 1380 & 100 < j < 1380 & area_nuclear <= 350 & dapi_median_nuclear < 40000 ',
replist = [1,2,3], nbins=50,
feature='dapi_gfp_corr_nuclear', pal = 'green', plot_nt = True, range_vals = (-1,1),
alpha=.05, pval_sort = False)
##
# +
df = pd.read_hdf('m139.hdf')
df = df.sort_values('well')
df.gene = df.gene.astype('category')
sorter = ['nontargeting','DDX58','MAVS','ATP13A1','CAPN15','ATP2B1','MAU2','MED16','MED24',
'TADA2B']
df.gene.cat.set_categories(sorter, inplace=True)
df = df.sort_values(["gene"])
df.gene = df.gene.astype('string')
aucs, grped = produce_barplot_general(df, df_name = 'm139', pshow = False,
genes = sorter,
gate = '100 < i <1380 & 100 < j < 1380 & area < 500 & area > 50 & channel_cell_median < 40000',
replist = [1,2,3,4], nbins=50,
feature='channel_cell_median', pal = 'red', plot_nt = True, range_vals = (200,5000),
alpha=.05, pval_sort = False)
##
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import spacy
import pandas as pd
import en_core_web_lg
from stanfordcorenlp import StanfordCoreNLP
import json
from collections import defaultdict
import nltk
# <img src="../diagram.png" style="height: 50px; width: 1000px;"/>
# Methods investigated Flowchart
starwars_text = 'Darth Vader, also known by his birth name Anakin Skywalker, is a fictional character in the Star Wars franchise. Darth Vader appears in the original film trilogy as a pivotal antagonist whose actions drive the plot, while his past as Anakin Skywalker and the story of his corruption are central to the narrative of the prequel trilogy. The character was created by George Lucas and has been portrayed by numerous actors. His appearances span the first six Star Wars films, as well as Rogue One, and his character is heavily referenced in Star Wars: The Force Awakens. He is also an important character in the Star Wars expanded universe of television series, video games, novels, literature and comic books. Originally a Jedi who was prophesied to bring balance to the Force, he falls to the dark side of the Force and serves the evil Galactic Empire at the right hand of his Sith master, Emperor Palpatine (also known as Darth Sidious).'
starwars_text
starwars_text = '''Iron Man is a fictional superhero appearing in American comic books published by Marvel Comics. The character was co-created by writer and editor Stan Lee, developed by scripter Larry Lieber, and designed by artists Don Heck and Jack Kirby. The character made his first appearance in Tales of Suspense #39 (cover dated March 1963), and received his own title in Iron Man #1 (May 1968). Also in 1963, the character founded the Avengers alongside Thor, Ant-Man, Wasp and the Hulk. A wealthy American business magnate, playboy, philanthropist, inventor and ingenious scientist, Anthony Edward "Tony" Stark suffers a severe chest injury during a kidnapping. When his captors attempt to force him to build a weapon of mass destruction, he instead creates a mechanized suit of armor to save his life and escape captivity. Later, Stark develops his suit, adding weapons and other technological devices he designed through his company, Stark Industries. He uses the suit and successive versions to protect the world as Iron Man. Although at first concealing his true identity, Stark eventually publicly reveals himself to be Iron Man. Initially, Iron Man was a vehicle for Stan Lee to explore Cold War themes, particularly the role of American technology and industry in the fight against communism. Subsequent re-imaginings of Iron Man have transitioned from Cold War motifs to contemporary matters of the time. Throughout most of the character's publication history, Iron Man has been a founding member of the superhero team the Avengers and has been featured in several incarnations of his own various comic book series. Iron Man has been adapted for several animated TV shows and films. The Marvel Cinematic Universe character was portrayed by Robert Downey Jr. in the Marvel Cinematic Universe films Iron Man (2008), The Incredible Hulk (2008) in a cameo, Iron Man 2 (2010), The Avengers (2012), Iron Man 3 (2013), Avengers: Age of Ultron (2015), Captain America: Civil War (2016), Spider-Man: Homecoming (2017), Avengers: Infinity War (2018) and Avengers: Endgame (2019). The character also appeared in Spider-Man: Far From Home (2019) and in the upcoming Black Widow (2021) through archive footage.'''
starwars_text
# > Note: 6 sentences
# # SpaCy NER
# +
nlp = spacy.load("en_core_web_lg")
doc = nlp(starwars_text)
ner_dict = {}
for x in doc.ents:
ner_dict[x.text] = x.label_
ner_dict
# -
# # Stanford NER
# > Note: Does not perform well at all compared to SpaCy NER. Able to recognize PERSONs but not in partial fragments. Not able to recognize entities other than LOCATION or PERSON such as WORK_OF_ART or DATE, etc
# +
# # NLTK
# # sentences = nltk.sent_tokenize(starwars_text)
# spaCy
run_this=0
if run_this==1:
nlp = spacy.lang.en.English()
nlp.add_pipe(nlp.create_pipe('sentencizer'))
doc = nlp(starwars_text)
sentences = [sent.string.strip() for sent in doc.sents]
ner_tagger = nltk.tag.StanfordNERTagger("./stanford-ner-2018-10-16/classifiers/english.all.3class.distsim.crf.ser.gz", "./stanford-ner-2018-10-16/stanford-ner.jar")
ner_dict = {}
results = []
nlp = spacy.lang.en.English()
tokenizer = spacy.tokenizer.Tokenizer(nlp.vocab)
for sent in sentences:
words = [token.orth_ for token in tokenizer(sent)]
print(words)
tagged = ner_tagger.tag(words)
results += tagged
for res in results:
ner_dict[res[0]] = res[1]
# -
ner_dict
# # Coreference Resolution
# ## TODO: Look into Neural Coref from Huggingface: https://github.com/huggingface/neuralcoref
# Look into CoreNLP base model for Python
# https://stanfordnlp.github.io/CoreNLP/coref.html
# > fixed root permission error: https://github.com/Lynten/stanford-corenlp/issues/26
# ### Generate coreferences and dependencies
nlp = StanfordCoreNLP("./stanford-corenlp-4.2.0", quiet=False)
annotated = nlp.annotate(starwars_text, properties={'annotators': 'coref', 'pipelineLanguage': 'en'})
result = json.loads(annotated)
corefs = result['corefs']
corefs
# ### Resolve coreferences
corefs = result['corefs']
print("Coreferences found: ",len(corefs))
print("Named entities: " , ner_dict.keys())
replace_coref_with = []
sentence_wise_replacements = defaultdict(list)
sentence_wise_replacements
# +
sentences = nltk.sent_tokenize(starwars_text)
# nlp = spacy.lang.en.English()
# nlp.add_pipe(nlp.create_pipe('sentencizer'))
# doc = nlp(starwars_text)
# sentences = [sent.string.strip() for sent in doc.sents]
print('Number of sentences: ', len(sentences))
print(sentences)
# -
# > Note: Here, nltk sentence tokenizer is more accurate than spaCy
# ### Organize corefs and replacements
# +
for index,coreferences in enumerate(corefs.values()):
replace_with = coreferences[0]
for reference in coreferences:
if reference["text"] in ner_dict.keys() or reference["text"][reference["headIndex"]-reference["startIndex"]] in ner_dict.keys():
replace_with = reference
sentence_wise_replacements[reference["sentNum"]-1].append((reference,index))
replace_coref_with.append(replace_with["text"])
sentence_wise_replacements[0].sort(key=lambda tup: tup[0]["startIndex"])
# -
# ### Pronoun Replacement with Named Entity
# nlp = spacy.lang.en.English()
# tokenizer = spacy.tokenizer.Tokenizer(nlp.vocab)
tokenizer = nltk.word_tokenize
# +
#Carry out replacement
for index,sent in enumerate(sentences):
replacement_list = sentence_wise_replacements[index]
for item in replacement_list[::-1]:
to_replace = item[0]
replace_with = replace_coref_with[item[1]]
replaced_sent = ""
words = tokenizer(sent)
for i in range(len(words)-1,to_replace["endIndex"]-2,-1):
replaced_sent = words[i] + " " + replaced_sent
replaced_sent = replace_with + " " + replaced_sent
for i in range(to_replace["startIndex"]-2,-1,-1):
replaced_sent = words[i] + " " + replaced_sent
#print(replaced_sent)
sentences[index] = replaced_sent
result = ""
for sent in sentences:
result += sent
# -
# ### Original Text
starwars_text
# ### New Text
# TODO: fix the weird spacing
result
# # Relation Extraction of using Stanford OpenIE
# Subject removal -> not URI (Literals)
# +
from openie import StanfordOpenIE
triples = []
with StanfordOpenIE() as client:
for triple in client.annotate(result):
triples.append(triple)
triples = pd.DataFrame(triples)
triples.head(20)
# -
triples
# ## TODO: Try out MinIE and/or Allenai OpenIE-standalone
# # Named Entity and Triple Matching
entity_set = set(ner_dict.keys())
entity_set
# #### Following needs to be optimized to reduce loss of knowledge
final_triples = []
for row, col in triples.iterrows():
col['subject'] = col['subject'].strip()
# check if Named Entity in subject sentence fragment
found_entity = False
for named_entity in entity_set:
if named_entity in col['subject']:
col['subject'] = named_entity
found_entity = True
if found_entity:
added = False
entity2_sent = col['object']
for entity in entity_set:
# if entity in entity2_sent:
# final_triples.append(
# (ner_dict[col['subject']], col['subject'], col['relation'], 'O', col['object']))
# added = True
# if not added:
final_triples.append(('Node', col['subject'], col['relation'], 'Node', col['object']))
final_triples
final_df = pd.DataFrame(final_triples, columns=['Type1','Entity1','Relationship','Type2', 'Entity2']).drop_duplicates()
final_df
# final_df.to_csv('starwars1_processed.csv', encoding='utf-8', index=False)
# > starwars1_processed Graph Visualization: https://graphcommons.com/graphs/01252887-9a23-4b33-a06d-02729a330beb
# > Graph, using Stanford NER: https://graphcommons.com/graphs/1f5d76f7-69ad-4575-83dd-4c90afab7059
# # Triple Linking
# ## Similarity with BERT
# > Note this is limited due to average of word vectors
import en_trf_bertbaseuncased_lg
nlp = en_trf_bertbaseuncased_lg.load()
index = 0
for _,col1 in final_df.iterrows():
head = col1['Entity2']
doc1 = nlp(head)
for _,col2 in final_df.iterrows():
tail = col2['Entity2']
if head == tail:
continue
doc2 = nlp(tail)
confidence = doc1.similarity(doc2)
if confidence > 0.85: # 85% seems to work pretty well
# Perform logic for linking
new_tail = head if len(tail)<len(head) else tail
col1['Entity2'] = new_tail
col2['Entity2'] = new_tail
print("Sentence 1:", doc1)
print("Sentence 2:", doc2)
print("Similarity:", confidence)
index += 1
print('Processed {} out of {}'.format(index,len(final_df)))
print()
final_df = final_df.drop_duplicates()
final_df
final_df.to_csv('starwars_linked_processed.csv', encoding='utf-8', index=False)
# > https://graphcommons.com/graphs/aae63b3e-870d-4c2e-83e4-bbca9f297b42
# # Sentence Transformers
# > https://github.com/UKPLab/sentence-transformers
from sentence_transformers import SentenceTransformer, util
model = SentenceTransformer('paraphrase-distilroberta-base-v1')
# bert-base-nli-mean-tokens
# https://huggingface.co/sentence-transformers/bert-base-nli-mean-tokens
# %debug
# +
sentences1 = ['The cat sits outside',
'A man is playing guitar',
'The new movie is awesome']
sentences2 = ['The dog plays in the garden',
'A woman watches TV',
'The new movie is so great']
embeddings1 = model.encode(sentences1, convert_to_tensor=True)
embeddings2 = model.encode(sentences2, convert_to_tensor=True)
cosine_scores = util.pytorch_cos_sim(embeddings1, embeddings2)
for i in range(len(sentences1)):
print("{} \t\t {} \t\t Score: {:.4f}".format(sentences1[i], sentences2[i], cosine_scores[i][i]))
# -
index = 0
for _,col1 in final_df.iterrows():
head = col1['Entity2']
doc1 = nlp(head)
for _,col2 in final_df.iterrows():
tail = col2['Entity2']
if head == tail:
continue
doc2 = nlp(tail)
confidence = doc1.similarity(doc2)
if confidence > 0.85: # 85% seems to work pretty well
# Perform logic for linking
new_tail = head if len(tail)<len(head) else tail
col1['Entity2'] = new_tail
col2['Entity2'] = new_tail
print("Sentence 1:", doc1)
print("Sentence 2:", doc2)
print("Similarity:", confidence)
index += 1
print('Processed {} out of {}'.format(index,len(final_df)))
print()
# # Textual Entailment with Keras_Parikh_Entailment
# > https://github.com/explosion/spaCy/tree/master/examples/keras_parikh_entailment
import en_vectors_web_lg
nlp = en_vectors_web_lg.load()
final_triples
# # Post Process & Entity Linking to existing Turtle Knowledge Bases
import rdflib
graph = rdflib.Graph()
graph.parse('../data/starwars.ttl', format='turtle')
# +
query_str = """
SELECT ?s ?p ?o
WHERE {
?s ?p ?o.
#FILTER(?s="Darth Vader")
}
#LIMIT 10
"""
res = graph.query(query_str)
# for s,p,o in res:
# print(s, '->', p, '->', o)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="JFH6OAGhx3fH"
# # "Evaluating penalty takers using empirical Bayes estimation"
# > "After using empirical Bayes estimation to model predicted penalty conversion rate, we take a look at the best and worst penalty takers, investigate Manchester City and Fulham's struggles from spot kicks, and use our new estimate to simulate the Euro 96 penalty shootout."
#
# - toc: true
# - branch: master
# - badges: true
# - comments: true
# - author: Tom Whelan
# - categories: [Bayes, football, visualisation]
# - image: images/cover_bayes_penalties.png
# + [markdown] id="uToytdlZ0z0T"
# # Why do we assume every player is equally skilled from the penalty spot?
#
# Last weekend there were two big penalty misses in the Premier league, one by Kevin De Bruyne against Liverpool and the other by Ademola Lookman against West Ham, both of which resulted in dropped points for their respective teams. It's rare to see two penalties that bad in the same weekend - in fact the last time someone completely missed the target from the spot in the Premier league [also cost Manchester City three points against Liverpool!](https://talksport.com/football/786186/kevin-de-bruyne-penalty-miss-liverpool-premier-league-stat-man-city/) So why was Lookman even taking Fulham's penalty in the first place, and are City so bad at penalties that [Ederson might actually be the best man for the job?](https://www.manchestereveningnews.co.uk/sport/football/football-news/man-city-penalties-ederson-gundogan-17676765)
#
# Trying to [quantify finishing skill](https://statsbomb.com/2017/07/quantifying-finishing-skill/) is not a new idea in the football analytics community, but penalties are usually an afterthought in the analysis (if they are considered at all). I've seen plenty of posts about expected goals (I've even [written some](http://www.fantasyfutopia.com/python-for-fantasy-football-introduction-to-machine-learning/)), and the typical process of dealing with penalties is to just throw away the data and assume penalty xG = penalties taken * average conversion rate. I have been guilty of that myself, but are we really saying [Gabriel Jesus](https://www.transfermarkt.com/gabriel-jesus/elfmetertore/spieler/363205) (4/10 penalties scored) is just as good as [Yaya Touré](https://www.transfermarkt.com/yaya-toure/elfmetertore/spieler/13091) (15/15)? Is Touré the same as [Matt Le Tissier](https://www.transfermarkt.com/matt-le-tissier/elfmetertore/spieler/43705) (27/27)? There are plenty of 'best penalty takers of all time' articles that suggest otherwise (1.16 million results on Google). We can do better.
#
# Here are some typical reasons people give for ignoring finishing skill estimates:
#
# 1. On-ball data is noisy and we are missing key information about defender positions, whether the shot with the player's strong or weak foot and countless other variables.
# 2. The sample size of shots from any given location is small.
# 3. Even if we could find some signal in the noise, there probably isn't much difference between the best finisher and the worst anyway.
#
# Whilst you *might* be able to get away with that line of thinking in general, it seems odd to apply that logic to penalties, since:
#
# 1. The most important concerns aren't a factor here; the main differences between one penalty and another are [goalkeeper skill](https://youtu.be/o3NKSLKTeDM?t=12), [pitch conditions](https://youtu.be/WlEUdZgH0gc?t=193), and (dare I say it!) confidence. We could make this process significantly more complicated by trying to account for those variables, but that might be overthinking things given what we're trying to accomplish. Unlike open-play shots a rocket into the top corner isn't necessarily better than a delicate chip down the middle (unless your name is Ademola Lookman!), so we can focus more on the results than the execution. If a club wanted to use this process to find their best penalty taker ***these variables could be controlled***, for example by having a penalty shootout (pressure/competitive element) at the end of training (same goalkeeper/pitch conditions) to build up a large sample size of penalty shots for each player in the squad, so a simple model could be just as useful in practice as a more complex one.
# 2. We still won't have a huge sample size with penalties, but at least the shot location is fixed.
# 3. Intuitively we know there is at least *some* difference, so why don't we try to investigate further?
# + [markdown] id="TZNQe-f4-Eou"
# # Empirical Bayes estimation
#
# There are several methods we could use to create a penalty taking skill estimate, but by far the easiest is [*'empirical Bayes estimation'*](https://en.wikipedia.org/wiki/Empirical_Bayes_method).
#
# > Important: This analysis is heavily inspired by David Robinson's excellent post [*'Understanding empirical Bayes estimation (using baseball statistics)'*](http://varianceexplained.org/r/empirical_bayes_baseball/). Since I prefer Python to R I'll be replicating some of the steps he used but I won't be going as in-depth, so I highly suggest reading through his post as well if you have time!
#
#
# As you'll see in a moment we have data on penalties scored and penalties taken for different players, and we want to estimate penalty conversion rate (scored/taken). Robinson has shown that data in this form can be modelled using a beta distribution. [In his words](http://varianceexplained.org/statistics/beta_distribution_and_baseball/):
# > "The beta distribution can be understood as representing a probability distribution *of probabilities* - that is, it represents all the possible values of a probability when we don’t know what that probability is."
#
# In our case the probability we are looking to estimate is penalty conversion rate (or 'probability of a succesful penalty'). Of course we could just take the actual rate, but that's not very useful in practice. Say John Smith has scored 3/3 penalties, do we really think he is incapable of missing? It would be preferable to ask 'what is our realistic best estimate of Smith's conversion rate *given the fact* that he has scored 3/3 so far?' This method is known as [*'Bayesian inference'*](https://en.wikipedia.org/wiki/Bayesian_inference); we start with a *prior* estimate of conversion rate (e.g. the league average distribution) and *update* our estimate to reflect the new evidence we have on Smith (3/3 penalties scored).
#
# > Note: I'm not going to spend much time explaining [Bayes' Theorem](https://en.wikipedia.org/wiki/Bayes%27_theorem), so if you haven't come across it before see [here](https://www.lesswrong.com/posts/XTXWPQSEgoMkAupKt/an-intuitive-explanation-of-bayes-s-theorem) for a primer (or [here](https://betterexplained.com/articles/an-intuitive-and-short-explanation-of-bayes-theorem/) for the short version).
#
#
# In standard Bayesian inference we usually decide on the prior distribution ahead of time, but we can approximate this method by *estimating the prior distribution from our data* instead (hence *'empirical estimation'*). To obtain our prior we'll follow Robinson's method - fit a beta distribution to the data and use that as a starting point for each player or team's prediction.
#
# + [markdown] id="PsaDtkIUcy0Y"
# ## Estimate a prior from the data
# + id="zfPzT09Xidxp" executionInfo={"status": "ok", "timestamp": 1605692180185, "user_tz": 0, "elapsed": 443, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}}
#hide
# %reload_ext autoreload
# %autoreload 2
# %matplotlib inline
# + id="OjlbXpPSiih7" executionInfo={"status": "ok", "timestamp": 1605692180429, "user_tz": 0, "elapsed": 339, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}}
#hide
import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
import seaborn as sns
import scipy.stats as ss
import altair as alt
from ipywidgets import widgets, interact
from IPython.display import display, HTML
sns.set(style='darkgrid', color_codes=True)
sns.set_context('notebook', font_scale=1.05, rc={'lines.linewidth': 2})
pd.options.display.float_format = '{:.2f}'.format
# + [markdown] id="ZA19itYHI1CJ"
# The main dataset we will be using is from FBRef's [Big 5 European Leagues Stats](https://fbref.com/en/comps/Big5/stats/players/Big-5-European-Leagues-Stats) page. Let's load it in now.
#
# > Note: I am ignoring goalkeeper skill for this analysis, but goalkeeper data is also available at [FBRef](https://fbref.com/en/comps/Big5/keepers/players/Big-5-European-Leagues-Stats) if you want to repeat the steps to estimate penalty save percentage instead! If you aren't familiar with Python I wrote an introductory series that you can check out [here](http://www.fantasyfutopia.com/python-for-fantasy-football-introduction/).
# + id="GkIsKEdkima4" colab={"base_uri": "https://localhost:8080/", "height": 204} executionInfo={"status": "ok", "timestamp": 1605692181480, "user_tz": 0, "elapsed": 538, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="e7a62d09-a80b-4dd6-9b44-6a9496423957"
#collapse-hide
df = pd.read_csv('https://raw.githubusercontent.com/twhelan22/blog/master/data/big_five_penalties.csv',
encoding='utf-8')
df.head()
# + [markdown] id="dac2IEwK6Sef"
# The dataset contains penalty statistics for players in France, Germany, Italy, Spain and England's top division from the 92/93 season to November 2020. Whilst that sounds like a lot of data, most of the players have only taken a handful of penalties:
# + id="KkrSWcLb8V5D" colab={"base_uri": "https://localhost:8080/", "height": 297} executionInfo={"status": "ok", "timestamp": 1605692182916, "user_tz": 0, "elapsed": 480, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="c772ec72-e411-440f-8925-aebc697f16ac"
#collapse-hide
players = df.groupby('name')[['penalties_scored', 'penalties_taken']].sum().reset_index()
def conversion_rate(df):
df['conversion_rate'] = df['penalties_scored'] / df['penalties_taken']
return
conversion_rate(players)
players.describe()
# + [markdown] id="oe0xHfuP_eWK"
# This means that over half of the players in the dataset have a conversion rate of 100% or 0%:
# + id="TDrQPFGz_RK9" colab={"base_uri": "https://localhost:8080/", "height": 364} executionInfo={"status": "ok", "timestamp": 1605692185148, "user_tz": 0, "elapsed": 1096, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="2c597bfe-25cf-43b1-ea9b-f3881117d102"
#collapse-hide
sns.displot(data=players, x='conversion_rate', kde=True);
# + [markdown] id="eQCun1f-9YDr"
# Clearly those players would add a lot of noise to our estimate, but we don't want to just throw out a big chunk of data if we can help it. To get around this problem, we can `groupby` 'team' and fit a beta distribution to the resulting team-level data instead. We can then use that prior to get predictions for each player afterwards.
#
# > Note: If you have a bigger dataset you could use players to get the prior instead!
# + id="hUzE5w1yjvX9" colab={"base_uri": "https://localhost:8080/", "height": 364} executionInfo={"status": "ok", "timestamp": 1605692186974, "user_tz": 0, "elapsed": 1113, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="0f94ca16-3247-4370-e0e9-32f7541e4e36"
#hide_input
teams = df.groupby('team')[['penalties_scored', 'penalties_taken']].sum().reset_index()
conversion_rate(teams)
sns.displot(data=teams, x='conversion_rate', kde=True);
# + [markdown] id="p8RvtNmwdAsz"
# That looks much more reasonable already! Let's filter out teams with fewer than 10 attempts and see what we're left with.
# + id="Wyg1rIJnkeJC" colab={"base_uri": "https://localhost:8080/", "height": 364} executionInfo={"status": "ok", "timestamp": 1605692189395, "user_tz": 0, "elapsed": 1183, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="0489882a-926f-4cc8-d197-02ae5b4ad143"
#hide_input
teams_filt = teams.copy()[teams['penalties_taken']>10]
sns.displot(data=teams_filt, x="conversion_rate", kde=True);
# + [markdown] id="yXsRULyc8Zj-"
# This is what we'd expect to see intuitively; most of the teams are close to the average, with a few teams having performed significantly better or worse than average. Let's try to fit a beta distribution to this data:
# + id="JXgHTHJSkxgZ" colab={"base_uri": "https://localhost:8080/", "height": 342} executionInfo={"status": "ok", "timestamp": 1605692191290, "user_tz": 0, "elapsed": 933, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="d18f3d3f-69f5-4f5f-e210-c90673bf4d93"
#collapse-hide
# Plot the distribution of actual conversion rate (our original data)
palette = sns.color_palette()
fig, ax = plt.subplots(figsize=(8,5))
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
sns.kdeplot(data=teams_filt['conversion_rate'])
# Fit a beta distribution to the data to get the alpha0 and beta0 parameters
# Note that for this to work 0 < data < 1, which is OK in this case,
# since a predicted conversion rate of 0% or 100% isn't realistic in practice
alpha0, beta0, _, _ = ss.beta.fit(teams_filt['conversion_rate'], floc=0, fscale=1)
# Generate a beta distribution using alpha0 and beta0 (the prior distribution)
prior_dist = ss.beta.rvs(alpha0, beta0, size=10000)
# Plot the random beta distribution we just generated
sns.kdeplot(data=prior_dist)
# Add legend
custom_lines = [Line2D([0], [0], color=palette[0], lw=2.5),
Line2D([0], [0], color=palette[1], lw=2.5)]
ax.legend(custom_lines, ['Actual conversion rate',
'Random beta distribution:\nalpha0={:.2f}, beta0={:.2f}'.format(alpha0, beta0)]);
# + [markdown] id="3GyEwU_gl9lv"
# That looks good enough for what we are trying to acomplish here! The beta distribution we just generated is defined as:
#
# $X\sim Beta(\alpha_0,\beta_0)$
#
# So what are $\alpha_0$ and $\beta_0$? In this case $\alpha_0$ = penalties scored and $\beta_0$ = penalties missed. With zero evidence we are going to start with the assumption that every player or team has scored $\alpha_0$ times and missed $\beta_0$ times. Our prior estimate of conversion rate is therefore:
#
# $prior\:estimate = \frac{starting\:goals}{starting\:goals\:+\:starting\:misses} = \frac{\alpha_0}{\alpha_0\:+\:\beta_0}$
#
# We are essentially giving everyone a 'head start' by assuming they have already taken some penalties and converted them at an average rate, which gets around the issue of small sample sizes. To incorporate the additional evidence we have for a particular player or team, we update their distribution as follows:
#
# $Beta(\alpha_0\:+\:goals,\beta_0\:+\:misses)$
#
# Let's take a look at this in action to get a better understanding of the process.
# + [markdown] id="VXqCzxk9an7z"
# ## Visualising the effects of empirical Bayes
# + id="cyQrP-EEYrpE" colab={"base_uri": "https://localhost:8080/", "height": 905} executionInfo={"status": "ok", "timestamp": 1605692201244, "user_tz": 0, "elapsed": 1606, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="184e2a8a-4292-4c68-ec0e-0d01813c7f38"
#collapse-hide
# Define a function to get predicted conversion rate using alpha0 and beta0
def predicted_conversion(scored, taken, alpha=alpha0, beta=beta0):
return (alpha0 + scored) / (alpha0 + beta0 + taken)
prior = predicted_conversion(scored=0, taken=0)
print('Start off with alpha0 = {:.2f} goals and beta0 = {:.2f} misses:'.format(alpha0, beta0))
print('Prior estimate = {:.2f} / ({:.2f} + {:.2f}) = {:.2%}\n'.format(alpha0, alpha0, beta0, prior))
print('Then every time a penalty is taken, add the results to the starting estimate:')
print('New estimate = (alpha0 + penalties_scored) / (alpha0 + beta0 + penalties_taken)\n')
sns.set(style='ticks')
def plot_dist(scored, missed):
taken = scored + missed
new_estimate = predicted_conversion(scored=scored, taken=taken)
# Plot the prior distribution
fig, ax = plt.subplots(figsize=(9,6))
ax.set(title='After {:n} taken, {:n} scored: estimate = ({:.2f} + {:n}) / ({:.2f} + {:.2f} + {:n}) = {:.2%}'.format(taken, scored, alpha0, scored, alpha0, beta0, taken, new_estimate),
ylim=[0, 8],
xlabel='Predicted penalty conversion rate')
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
sns.kdeplot(data=prior_dist, color=palette[-1], fill=True)
plt.axvline(prior, 0, 0.95, color=palette[-1], linestyle='--')
# Plot the new distribution
new_dist = ss.beta.rvs(alpha0+scored, beta0+missed, size=10000)
sns.kdeplot(data=new_dist, color=palette[3])
plt.axvline(new_estimate, 0, 0.95, color=palette[3], linestyle='--')
# Add custom legend and axes
custom_lines = [Line2D([0], [0], color=palette[3], lw=2.5),
Line2D([0], [0], color=palette[-1], lw=2.5)]
ax.legend(custom_lines,
['New estimate: %s' % (str(round(new_estimate*100, 2)))+'%',
'Prior estimate: %s' % (str(round(prior*100, 2)))+'%'],
loc='upper left')
sns.despine(right=True, top=True);
plot_dist(1, 0)
plot_dist(10, 1)
# + [markdown] id="RyLG9FUvC0H-"
# After 1 taken, 1 scored our new estimate is very similar to the prior distribution - we don't want to make drastic changes after just one penalty! After 11 taken, 10 scored the new distribution is taller and narrower, since we are starting to get more confident in our estimate now we have more information. The new distribution has also shifted to the right, since we think it's more likely this player is above average. However, even with more evidence this player's predicted conversion rate of 80.61% is still closer to the *average rate* than the his *actual* conversion rate of 90.9%.
#
# The process of pulling estimates back towards the average is sometimes referred to as *'shrinkage'*, which is illustrated more clearly in the interactive chart below. Teams with a small number of attempts are pulled back towards the prior estimate (the horizontal line) significantly, whereas teams with > 150 attempts have a predicted conversion rate close to their actual conversion rate (i.e. close to the diagonal line). In other words, more evidence = less shrinkage, and vice versa.
# + id="M-pQSqBVfj10" colab={"base_uri": "https://localhost:8080/", "height": 590} executionInfo={"status": "ok", "timestamp": 1605692211407, "user_tz": 0, "elapsed": 517, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="e1fa64bc-3918-48ef-d6af-308752efc121"
#collapse-hide
teams = teams.assign(predicted_conversion=predicted_conversion(teams['penalties_scored'], teams['penalties_taken']))
# Set colour scheme to update automatically for each chart
scheme = 'inferno'
col1 = matplotlib.colors.to_hex(sns.color_palette(scheme)[0])
col2 = matplotlib.colors.to_hex(sns.color_palette(scheme)[-1])
# Create an interactive scatter plot from teams showing predicted and actual conversion rate
selection = alt.selection_single(on='mouseover');
points = alt.Chart(teams).mark_circle(size=50).add_selection(
selection
).encode(
x=alt.X('conversion_rate', scale=alt.Scale(domain=(0.1, 1.1)), axis=alt.Axis(format='%', title='Actual conversion rate')),
y=alt.X('predicted_conversion', scale=alt.Scale(domain=(0.685, 0.875)), axis=alt.Axis(format='%', title='Predicted conversion rate')),
color=alt.condition(selection, 'penalties_taken:Q', alt.value('grey'),
legend=alt.Legend(title='Penalties taken'),
scale=alt.Scale(scheme=scheme)),
opacity=alt.condition(selection, alt.value(0.8), alt.value(0.1)),
tooltip=['team', 'penalties_scored', 'penalties_taken',
alt.Tooltip('conversion_rate', format='.2%'),
alt.Tooltip('predicted_conversion', format='.2%')]
).interactive().properties(
width=500,
height=500,
title='As the number of penalties taken increases, predicted rate approaches actual rate'
)
# Add horizontal line at y = alpha0 / (alpha0 + beta0)
overlayh = pd.DataFrame({'y': [prior]})
hline = alt.Chart(overlayh).mark_rule(color=col1, strokeWidth=2).encode(y='y:Q')
overlayhtext = pd.DataFrame({'x': [0.4], 'y': [prior], 'text': ['Prior: y = alpha0 / (alpha0 + beta0)']})
htext = alt.Chart(overlayhtext).mark_text(color=col1, fontSize=15, baseline='bottom').encode(alt.X('x:Q'), alt.Y('y:Q'), alt.Text('text'))
# Add diagonal line at y = x
overlayd = pd.DataFrame({'x': [-5, 0.7, 5], 'y': [-5, 0.7, 5], 'text': ['', 'y = x', '']})
dline = alt.Chart(overlayd).mark_line(color=col2, strokeWidth=2).encode(x='x:Q', y='y:Q')
dtext = alt.Chart(overlayd).mark_text(color=col2, fontSize=15, angle=285, baseline='top').encode(alt.X('x:Q'), alt.Y('y:Q'), alt.Text('text'))
alt.layer(points, hline, htext, dline, dtext
).configure_header(
titleFontSize=20,
titleFontWeight='normal'
).configure_axis(
labelFontSize=11,
titleFontSize=14,
titleFontWeight='normal'
).configure_legend(
labelFontSize=11,
titleFontSize=12,
titleFontWeight='normal'
)
# + [markdown] id="VqD9rycIT4qm"
# # Who are the best and worst penalty takers?
# + [markdown] id="dUtP7bfiegYn"
# As we saw earlier, most players in the dataset have only taken a handful of penalties, and some of the players ranked worst in our new metric were players that happened to miss several times in their first few attempts. It might be more interesting to look at players who have taken at least 15 penalties (i.e. a team's main penalty taker for multiple seasons) instead. Let's start with the worst players in the dataset:
# + id="OavvzVgAsll9" colab={"base_uri": "https://localhost:8080/", "height": 359} executionInfo={"status": "ok", "timestamp": 1605692214192, "user_tz": 0, "elapsed": 401, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="a7d0d27d-77da-4f5a-92e7-ebde269fa205"
#hide_input
pd.options.display.float_format = '{:.2%}'.format
players = players.assign(predicted_conversion=predicted_conversion(players['penalties_scored'], players['penalties_taken']))
players[players['penalties_taken']>=15].sort_values(by='predicted_conversion').head(10)
# + [markdown] id="6fAlyR-aYys7"
# Some surprising names there perhaps! Pirlo consistently pops up on '[best penalty takers'](https://www.sportyghost.com/top-10-best-penalty-takers-in-football-world/) lists, but even if we look at his overall record on [Transfermarkt](https://www.transfermarkt.com/andrea-pirlo/elfmetertore/spieler/5817) we get a predicted conversion rate of just 74.5%. [Roberto Baggio's](https://www.transfermarkt.com/roberto-baggio/elfmetertore/spieler/4153) career record, on the other hand, is much better than it looks here (83.2%).
#
# > Note: Transfermarkt's league coverage isn't exhaustive but I haven't yet found a more comprehensive resource for penalty stats, so I will be using their 'career' totals throughout the post to supplement the FBRef data.
#
#
# What about the best players in the dataset?
# + id="DuwgDUgktBbb" colab={"base_uri": "https://localhost:8080/", "height": 359} executionInfo={"status": "ok", "timestamp": 1605692216471, "user_tz": 0, "elapsed": 393, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="e67f023b-3c60-4d90-a616-7d4c4f820d94"
#hide_input
players[players['penalties_taken']>=15].sort_values(by='predicted_conversion', ascending=False).head(10)
# + [markdown] id="zTWEFChEWj7P"
# It's not surprising to see Le Tissier up there, since he is widely considered to be one of the best penalty takers ever. [Rickie Lambert](https://www.transfermarkt.com/rickie-lambert/elfmetertore/spieler/49655) only took a few penalties in the Premiership, but he is at 87.24% over his career in all competitions. If you are following along in notebook form you can investigate different players below; some notable names that weren't in the dataset include goalkeeper [Rogério Ceni](https://www.transfermarkt.com/rogerio-ceni/elfmetertore/spieler/13811) (84.11%), [Michel Platini](https://www.transfermarkt.com/michel-platini/elfmetertore/spieler/88994) (86.36%), [Marco Van Basten](https://www.transfermarkt.com/marco-van-basten/elfmetertore/spieler/74471) (86.46%), [Davor Suker](https://www.transfermarkt.com/davor-suker/elfmetertore/spieler/1407) (88.03%), [Ferenc Puskás](https://www.transfermarkt.com/ferenc-puskas/elfmetertore/spieler/103092) (88.19%), [Ronald Koeman](https://www.transfermarkt.com/ronald-koeman/elfmetertore/spieler/7940) (89.54%) and [Alan Shearer](https://www.transfermarkt.com/alan-shearer/elfmetertore/spieler/3110) (89.86%, more on him later!). The best I've found so far is [Hugo Sánchez](https://www.transfermarkt.com/hugo-sanchez/elfmetertore/spieler/84528), who's 65/65 record puts him at 91.57%!
#
# + colab={"base_uri": "https://localhost:8080/", "height": 80} id="RD4R4NVfrqTd" executionInfo={"status": "ok", "timestamp": 1605692918255, "user_tz": 0, "elapsed": 414, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="c7e0e071-8d6a-43fb-ceb4-617b54409754"
#collapse-hide
#@title Search for a player: { run: "auto", vertical-output: true }
text = 'Totti' #@param {type:"string"}
display(players[players['name'].str.contains(text)])
# Alternative method (non-Colab Jupyter notebooks)
def player_search():
text = widgets.Text()
display(text)
button = widgets.Button(description='Search')
display(button)
def on_button_clicked(b):
return display(players[players['name'].str.contains(text.value)])
button.on_click(on_button_clicked)
# + colab={"base_uri": "https://localhost:8080/"} id="sae8kJlIsjHo" executionInfo={"status": "ok", "timestamp": 1605692986225, "user_tz": 0, "elapsed": 585, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="5e54668a-d26c-4c0a-87eb-9956fae55741"
#collapse-hide
#@title Get predicted conversion rate: { run: "auto", vertical-output: true }
scored = 65 #@param {type:"slider", min:0, max:150, step:1}
missed = 0 #@param {type:"slider", min:0, max:150, step:1}
print('Scored:', scored, 'Missed:', missed)
print('Predicted conversion rate: {:.2%}'.format(predicted_conversion(scored, scored + missed)))
# Alternative method (non-Colab Jupyter notebooks)
def player_slider():
def slider(scored, missed):
print('Scored:', scored, 'Missed:', missed)
print('Predicted conversion rate: {:.2%}'.format(predicted_conversion(scored, scored + missed)))
interact(slider, scored=widgets.IntSlider(min=0, max=150, step=1, value=65),
missed=widgets.IntSlider(min=0, max=150, step=1, value=0))
# + [markdown] id="G5j0gcvEbcNv"
# You might have noticed that this is a rare top ten list without Messi, and in the past he has even been called out for being ['phenomenally bad'](https://www.joe.co.uk/sport/lionel-messis-barcelona-penalty-record-is-phenomenally-bad-16180?cacheTtl=5&cacheKey=request-browser-httpswwwjoecouksportlionel-messis-barcelona-penalty-record-is-phenomenally-bad16180) at penalties. Let's check whether that criticism was warranted.
# + [markdown] id="ktXR38DEMJw6"
# ## Is Lionel Messi 'phenomenally bad' at penalties?
# Pretty average, actually.
# + id="Yun48_ftMQwo" colab={"base_uri": "https://localhost:8080/", "height": 410} executionInfo={"status": "ok", "timestamp": 1605692286926, "user_tz": 0, "elapsed": 987, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="1968636d-aefd-4c2f-fb10-ccb2eea8cefe"
#collapse-hide
# Initialise the plot
fig, ax = plt.subplots(figsize=(9,6))
ax.set(title='Lionel Messi, Mr. Average',
ylim=[0, 13],
xlabel='Predicted penalty conversion rate')
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
# Generate a beta distribution representing the range of estimates for an average player
sns.kdeplot(data=prior_dist, color='maroon', fill=True, bw_adjust=3)
plt.axvline(prior, 0, 0.95, c='maroon', linestyle='--')
# Generate a beta distribution representing the range of estimates for Messi
# Note - using career numbers from Transfermarkt
# https://www.transfermarkt.com/lionel-messi/elfmetertore/spieler/28003
goals = 97
misses = 26
messi_dist = ss.beta.rvs(alpha0+goals, beta0+misses, size=10000)
sns.kdeplot(data=messi_dist, color='mediumblue', fill=True, bw_adjust=3)
est1 = predicted_conversion(goals, goals+misses)
plt.axvline(est1, 0, 0.95, c='mediumblue')
# Add custom legend and axes
custom_lines = [Line2D([0], [0], color='mediumblue', lw=2.5),
Line2D([0], [0], color='maroon', lw=2.5, linestyle='--')]
ax.legend(custom_lines,
['Messi: %s' % (str(round(est1*100, 1)))+'%',
'Prior: %s' % (str(round(prior*100, 1)))+'%'],
loc='upper left')
sns.despine(right=True, top=True);
# + [markdown] id="UEFXdAKbRzCH"
# The beta distribution for our prior estimate is shown in red, with Messi's beta distribution in blue.
#
# > Tip: Definitely make your charts look worse by using Barcelona colours!
#
#
# The distribution for Messi is taller and narrower than the prior distribution. This is because we have 123 penalty attempts for Messi, whereas our prior distribution starts off with a lot less, so we are more confident in Messi's prediction. We can also see that whilst Messi isn't 'phenomenally bad' at penalties, in this case we may have found something he doesn't excel at.
# + [markdown] id="ybqFZ3F6v9E5"
# # Are Manchester City bad at penalties?
# + id="BVs3XLM7Z_P_" colab={"base_uri": "https://localhost:8080/"} executionInfo={"status": "ok", "timestamp": 1605692289456, "user_tz": 0, "elapsed": 468, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="c65c06d2-21f2-408c-f2a0-14ce6b903bcb"
#collapse-hide
# Filter to the start of the 16/17 season
teams_since_16 = df[df['season']>2016].groupby('team')[['penalties_scored', 'penalties_taken']].sum().reset_index()
conversion_rate(teams_since_16)
teams_since_16 = teams_since_16.assign(predicted_conversion=predicted_conversion(teams_since_16['penalties_scored'], teams_since_16['penalties_taken']))
def percentile(all_scores, score):
return round(ss.stats.percentileofscore(all_scores, score), 1)
city_pct = percentile(teams_since_16['penalties_taken'], teams_since_16.set_index('team').loc['Manchester City', 'penalties_taken'])
print('Manchester City have taken more penalties than '+str(city_pct)+"% of teams\nin Europe's big five leagues since 16/17. However...")
# + id="CvwhOmCRbcqi" colab={"base_uri": "https://localhost:8080/", "height": 479} executionInfo={"status": "ok", "timestamp": 1605692291267, "user_tz": 0, "elapsed": 844, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="f520aa64-bd43-41e2-8c1d-0ba9ce9a9309"
#collapse-hide
palette = sns.color_palette()
score = teams_since_16.set_index('team').loc['Manchester City', 'predicted_conversion']
worse_or_equal = teams_since_16[teams_since_16['predicted_conversion']<=score]
worse_teams = len(worse_or_equal) - 1
# Create the main plot
fig, ax = plt.subplots(figsize=(10,7))
ax.set(title="Since Pep Guardiola took charge in 16/17, only %d teams in Europe's big five leagues\nhave a worse predicted penalty conversion rate than Manchester City" % (worse_teams),
ylim=[0, 20],
xlabel='Predicted penalty conversion rate')
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
sns.kdeplot(data=teams_since_16['predicted_conversion'], color='skyblue', fill=True)
plt.axvline(teams_since_16['predicted_conversion'].mean(), 0, 20, c='skyblue', linestyle='--')
lineheight = 0.65*teams_since_16[teams_since_16['team']=='Manchester City']['penalties_taken'].values[0]/teams_since_16['penalties_taken'].max()
textheight = 20.5*lineheight
plt.axvline(score, 0, lineheight, c=palette[0])
plt.text(score, textheight, 'Manchester City', c=palette[0], ha='right')
# Add rug - https://seaborn.pydata.org/generated/seaborn.rugplot.html#seaborn.rugplot
sns.rugplot(data=teams_since_16['predicted_conversion'], color='skyblue', height=0.035)
# Add legend
custom_lines = [Line2D([0], [0], color=palette[0], lw=2.5),
Line2D([0], [0], color='skyblue', lw=2.5, linestyle='--'),
Line2D([0], [0], color='skyblue', lw=2.5)]
ax.legend(custom_lines,
['Manchester City: %s' % (str(round(score*100, 1))+'%'),
'Average Team: %s' % (str(round(teams_since_16['predicted_conversion'].mean()*100, 1))+'%'),
'%d total teams' % (len(teams_since_16))])
# Remove axes
sns.despine(right=True, top=True);
# + id="jHrFHmd1eyAp" colab={"base_uri": "https://localhost:8080/", "height": 235} executionInfo={"status": "ok", "timestamp": 1605692293252, "user_tz": 0, "elapsed": 494, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="f846a947-b5fe-4c79-b64e-c0ec3c2ddeda"
#hide_input
pd.options.display.float_format = '{:.2%}'.format
worse_or_equal.sort_values('predicted_conversion', ascending=False)
# + [markdown] id="A5xZ71HhJEZX"
# There's always going to be some variance involved in a stat like that, but there could be other factors at play as well:
# + id="5YB3wqxAfp_L" colab={"base_uri": "https://localhost:8080/", "height": 518} executionInfo={"status": "ok", "timestamp": 1605692295500, "user_tz": 0, "elapsed": 1176, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="789fa30c-587f-4f3c-df10-68f86c40d3db"
#collapse-hide
# Data from https://www.transfermarkt.com/manchester-city/elfmeterschuetzen/verein/281
# KDB's estimate includes his miss against Liverpool
man_city_career = {'name': ['Elano', 'Yaya Touré', 'Sergio Agüero', 'Carlos Tevez', 'Robinho', 'Mario Balotelli', 'James Milner',
'Raheem Sterling', 'Kevin De Bruyne', 'Gabriel Jesus', 'İlkay Gündoğan', 'Riyad Mahrez'],
'penalties_scored': [23,15,47,24,12,38,30,
2,7,4,9,10],
'penalties_taken': [26,15,60,34,15,43,35,
4,9,10,10,16],
'align': ['left', 'left', 'left', 'right', 'left', 'left', 'center',
'center', 'right', 'right', 'center', 'right'],
'palette': [0,0,2,0,0,0,0,
2,2,2,1,2]}
man_city = pd.DataFrame.from_dict(man_city_career)
man_city = man_city.assign(predicted_conversion=predicted_conversion(man_city['penalties_scored'], man_city['penalties_taken'])).sort_values(by='predicted_conversion', ascending=False)
# Create the main plot
fig, ax = plt.subplots(figsize=(13,8))
ax.set(title='Hughes, Mancini and Pellegrini had far better options from the penalty spot than Pep Guardiola',
ylim=[0, 27],
xlabel='Predicted penalty conversion rate')
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
palette = sns.color_palette()
sns.kdeplot(data=players['predicted_conversion'], color='skyblue', fill=True, bw_adjust=3)
# Add mean
plt.axvline(players['predicted_conversion'].mean(), 0, 27, c='skyblue', linestyle='--')
for index, row in man_city.iterrows():
# Set line height to be proportional to number of penalties taken
lineheight = row['penalties_taken']/players['penalties_taken'].max()
textheight = 27.5*lineheight
plt.axvline(row['predicted_conversion'], 0, lineheight, c=palette[row['palette']])
plt.text(row['predicted_conversion'], textheight, row['name'], c=palette[row['palette']], ha=row['align'])
# Add rug
sns.rugplot(data=players['predicted_conversion'], color='skyblue', height=0.02)
# Add legend
custom_lines = [Line2D([0], [0], color=palette[0], lw=2.5),
Line2D([0], [0], color=palette[2], lw=2.5),
Line2D([0], [0], color=palette[1], lw=2.5),
Line2D([0], [0], color='skyblue', lw=2.5, linestyle='--'),
Line2D([0], [0], color='skyblue', lw=2.5),]
ax.legend(custom_lines, ['Mansour era\nbefore 16/17', 'Guardiola era', 'Current best', 'Average player', '%d total players' % (len(players))])
# Remove axes
sns.despine(right=True, top=True);
# + [markdown] id="3BanfzR_7rR-"
# We can clearly see a big difference here pre/post Pep (with the exception of Carlos Tevez, who mainly took penalties in 09/10 after Elano left). In fact, the wealth of options meant that James Milner was rarely called upon to take penalties for City. Balotelli famously never needs to look at the ball when he takes a penalty - Joe Hart once said that his penalties were [almost impossible to stop](https://www.goal.com/en-us/news/85/england/2012/03/17/2973811/hart-manchester-citys-balotelli-probably-the-best-penalty), which was far greater praise at the time than it would be now (sorry Joe!), and [did a lap of honour](https://www.manchestereveningnews.co.uk/sport/football/football-news/man-city-penalty-stats-gundogan-17614489) when he finally saved one in training. To answer our earlier question, not only is Yaya Touré significantly better than Gabriel Jesus, they are on opposite ends of the scale! Jesus is great at many aspects of the game, but from the penalty spot he's one of the worst players I've seen with a 70.15% predicted conversion rate.
#
#
# + id="1NncWCWwFh3C" colab={"base_uri": "https://localhost:8080/", "height": 410} executionInfo={"status": "ok", "timestamp": 1605692298210, "user_tz": 0, "elapsed": 1053, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="ed46c6a1-753b-4964-fc49-8ccbbfbfdc84"
#collapse-hide
# Plot the range of estimates for Yaya and Jesus
fig, ax = plt.subplots(figsize=(9,6))
ax.set(title='Yaya Touré and Gabriel Jesus are probably not equally skilled at taking penalties',
ylim=[0, 9],
xlabel='Predicted penalty conversion rate')
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
# Yaya
goals = 15
misses = 0
yaya_dist = ss.beta.rvs(alpha0+goals, beta0+misses, size=10000)
sns.kdeplot(data=yaya_dist, color=palette[0], fill=True, bw_adjust=1.5)
est1 = predicted_conversion(goals, goals+misses)
plt.axvline(est1, 0, 0.95, c=palette[0], linestyle='--')
# Jesus
goals = 4
misses = 6
jesus_dist = ss.beta.rvs(alpha0+goals, beta0+misses, size=10000)
sns.kdeplot(data=jesus_dist, color='skyblue', fill=True, bw_adjust=1.5)
est2 = predicted_conversion(goals, goals+misses)
plt.axvline(est2, 0, 0.95, c='skyblue', linestyle='--')
# Add custom legend and axes
custom_lines = [Line2D([0], [0], color='skyblue', lw=2.5),
Line2D([0], [0], color=palette[0], lw=2.5)]
ax.legend(custom_lines,
['Jesus: %s' % (str(round(est2*100, 1)))+'%',
'Touré: %s' % (str(round(est1*100, 1)))+'%'],
loc='upper left')
sns.despine(right=True, top=True);
# + [markdown] id="C5zoaLDQGGgi"
# Aside from his well publicised disagreements with Touré it's hard to blame Pep too much, since it appears his current squad are good at everything *but* penalties. İlkay Gündoğan's miss came at a time when City had already missed [three of their last five](https://www.thesun.co.uk/sport/football/10875632/man-city-penalty-ilkay-gundogan-pep-guardiola/) so we can certainly speculate that there would have been a lot of pressure to change things; in fact as I alluded to earlier things got so bad that [Pep was seriously considering putting Ederson in charge of spot kicks.](https://www.manchestereveningnews.co.uk/sport/football/football-news/man-city-penalties-ederson-gundogan-17676765) De Bruyne's miss against Liverpool bumped his estimate down to about league average, but he was still predicted to be a bit worse than Gündoğan before that:
# + id="Me-jkjfClpI1" colab={"base_uri": "https://localhost:8080/", "height": 410} executionInfo={"status": "ok", "timestamp": 1605692300443, "user_tz": 0, "elapsed": 1070, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="bb2cba6b-ec6c-4802-8a62-9986bd600948"
#collapse-hide
# Plot the range of estimates for KDB before and after his penalty against Liverpool
fig, ax = plt.subplots(figsize=(9,6))
ax.set(title="De Bruyne's predicted conversion rate decreased after his miss against Liverpool",
ylim=[0, 9],
xlabel='Predicted penalty conversion rate')
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
# Before Liverpool penalty
goals = 7
misses = 1
kdb_dist = ss.beta.rvs(alpha0+goals, beta0+misses, size=10000)
sns.kdeplot(data=kdb_dist, color='skyblue', fill=True, bw_adjust=1.5)
est1 = predicted_conversion(goals, goals+misses)
plt.axvline(est1, 0, 0.95, c='skyblue', linestyle='--')
# After Liverpool penalty
misses = 2
kdb_dist = ss.beta.rvs(alpha0+goals, beta0+misses, size=10000)
sns.kdeplot(data=kdb_dist, color=palette[0], bw_adjust=1.5)
est2 = predicted_conversion(goals, goals+misses)
plt.axvline(est2, 0, 0.95, c=palette[0], linestyle='--')
# Add custom legend and axes
custom_lines = [Line2D([0], [0], color=palette[0], lw=2.5),
Line2D([0], [0], color='skyblue', lw=2.5)]
ax.legend(custom_lines,
['New estimate: %s' % (str(round(est2*100, 1)))+'%',
'Old estimate: %s' % (str(round(est1*100, 1)))+'%'],
loc='upper left')
sns.despine(right=True, top=True);
# + id="OQVbpz6O5OLo" colab={"base_uri": "https://localhost:8080/"} executionInfo={"status": "ok", "timestamp": 1605692302762, "user_tz": 0, "elapsed": 519, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="fcca90f3-b626-490c-8af1-f4063ff59120"
#hide_input
gundo_pct = percentile(players['predicted_conversion'], man_city.set_index('name').loc['İlkay Gündoğan', 'predicted_conversion'])
gundo_rate = str(round(predicted_conversion(9, 10)*100, 2))+'%!'
print('İlkay Gündoğan is at the '+str(gundo_pct)+'th percentile of %d players in the dataset\nwith a predicted penalty conversion rate of' % (len(players)), gundo_rate)
# + [markdown] id="z03okXOeJFEh"
# This analysis suggests Gündoğan deserves another go, and I'd like to see him given the nod the next time he's on the pitch. We aren't talking about a massive difference between the two players, but why not take edges anywhere you can, even if they are small ones? We have to assume Ederson is worse than Gündoğan as well since we have no additional data, but if Ederson really is City's best penalty taker then why not use him - it can't really get much worse at this point!
# + [markdown] id="YzfESdaISX4d"
# # Why isn't Aleksandar Mitrović taking penalties for Fulham?
# + [markdown] id="iZPnEpM2ckpF"
# [Antonin Panenka](https://www.transfermarkt.com/antonin-panenka/elfmetertore/spieler/60800) (83.5% predicted conversion rate) might not have been too pleased with the result of Ademola Lookman's botched attempt against West Ham last weekend. Lookman was heavily criticised, and at the time I was wondering why Aleksandar Mitrović wasn't the one taking the penalty. Now I know why:
# + id="pUhri_y5CLfP" colab={"base_uri": "https://localhost:8080/", "height": 410} executionInfo={"status": "ok", "timestamp": 1605692304813, "user_tz": 0, "elapsed": 992, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="e494208f-0bd1-4bf6-c993-296b35b43a5f"
#collapse-hide
fulham_career = {'name': ['Aleksandar Mitrović', 'Tom Cairney', 'Ivan Cavaleiro', 'Ademola Lookman\n(before miss)'],
'penalties_scored': [15,2,6,0],
'penalties_taken': [22,3,7,0]}
fulham = pd.DataFrame.from_dict(fulham_career)
fulham = fulham.assign(predicted_conversion=predicted_conversion(fulham['penalties_scored'], fulham['penalties_taken'])).sort_values(by='predicted_conversion', ascending=False)
fulham['penalties_missed'] = fulham['penalties_taken'] - fulham['penalties_scored']
dist_df = pd.DataFrame()
for index, row in fulham.iterrows():
dist = ss.beta.rvs(alpha0+row['penalties_scored'], beta0+row['penalties_missed'], size=10000)
temp = pd.DataFrame({'predicted_conversion': dist})
temp['name'] = row['name']
dist_df = dist_df.append(temp)
fig, ax = plt.subplots(figsize=(10,6))
ax.set(title="It's not surprising that Aleksandar Mitrović isn't taking penalties for Fulham")
ax.xaxis.set_major_formatter(matplotlib.ticker.PercentFormatter(1))
sns.violinplot(data=dist_df, x='predicted_conversion', y='name', palette='light:dimgrey', inner='quart', orient='h', ax=ax)
plt.xlabel('Predicted penalty conversion rate')
plt.ylabel('')
sns.despine(right=True, top=True);
# + id="9joO-Jeq2ab-" colab={"base_uri": "https://localhost:8080/"} executionInfo={"status": "ok", "timestamp": 1605692307046, "user_tz": 0, "elapsed": 571, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="be4e6064-bbe5-4d80-dd44-5bd87217476e"
#hide_input
mitro_pct = percentile(players['predicted_conversion'], fulham.set_index('name').loc['Aleksandar Mitrović', 'predicted_conversion'])
mitro_rate = str(round(predicted_conversion(15, 22)*100, 2))+'%!'
print('Aleksandar Mitrović is at the '+str(mitro_pct)+'th percentile of %d players in the dataset\nwith a predicted penalty conversion rate of' % (len(players)), mitro_rate)
# + [markdown] id="5Pk4srzbNp4i"
# It's a good job Mitrović isn't first choice! Cavaleiro appears to be the best candidate by our estimate, but maybe Lookman showed something in training that set him apart from the rest - the Fulham coaches will have seen him take a lot more penalties than we have. Going for a 'Panenka' on your first attempt certainly suggests that you at least rate your own ability from the spot pretty highly, although if we use that logic maybe we should be recommending John Stones as City's go-to option...
# > youtube: https://youtu.be/nz3H72j8qyE
# + [markdown] id="6euiOv09675E"
# # Simulating the Euro 96 semi-final shootout
# + [markdown] id="v8p7MQc6RrCZ"
# At this point it seems inevitable to most England fans that every major tournament will end in a penalty shootout loss to Germany in the semis.
#
# 
#
# Let's have a look at one example, the Euro 96 shootout, and see whether that's really the case.
# + id="q__uXywx4PA4" colab={"base_uri": "https://localhost:8080/", "height": 421} executionInfo={"status": "ok", "timestamp": 1605692314527, "user_tz": 0, "elapsed": 452, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="d36f1b19-ea7c-4105-e719-28dea243964f"
#collapse-hide
# https://www.transfermarkt.com/spielbericht/index/spielbericht/935928
eng_career = {'name': ['Alan Shearer', 'Teddy Sheringham', 'Steve McManaman', 'Paul Ince', 'David Platt',
'Paul Gascoigne', 'Darren Anderton', 'Gareth Southgate', 'Tony Adams', 'Stuart Pearce',
'David Seaman', 'Robbie Fowler'],
'penalties_scored': [65,30,0,0,13,
1,6,0,0,10,
0,32],
'penalties_taken': [67,33,0,0,15,
1,6,0,0,10,
0,34],
'notes': [None, None, None, None, None,
None, None, None, None, None,
None, 'bench, not used']}
ger_career = {'name': ['Stefan Kuntz', 'Mehmet Scholl', 'Andreas Möller', 'Christian Ziege', 'Dieter Eilts',
'Stefan Reuter', 'Matthias Sammer', 'Markus Babbel', 'Andreas Köpke', 'Thomas Strunz',
'Thomas Häßler', 'Marco Bode', 'Oliver Bierhoff'],
'penalties_scored': [34,14,9,2,8,
10,0,0,2,4,
26,0,15],
'penalties_taken': [39,17,13,3,8,
15,0,0,2,5,
28,1,20],
'notes': [None, "subbed off 77'", None, None, None,
None, None, None, None, "subbed on 118'",
"subbed on 77'", "subbed on 110'", "bench, not used"]}
england = pd.DataFrame.from_dict(eng_career)
england = england.assign(predicted_conversion=predicted_conversion(england['penalties_scored'], england['penalties_taken'])).sort_values(by='predicted_conversion', ascending=False)
germany = pd.DataFrame.from_dict(ger_career)
germany = germany.assign(predicted_conversion=predicted_conversion(germany['penalties_scored'], germany['penalties_taken'])).sort_values(by='predicted_conversion', ascending=False)
england
# + [markdown] id="uX-16GvEmZU_"
# It looks like England actually had some good penalty takers available, particularly Shearer who has one of the highest predicted conversion rates we have found so far. Robbie Fowler was still young at the time, but it's notable that England didn't choose to bring him on just before the shootout despite having three substitutions remaining, since he was prolific from the spot later in his career.
# + id="uFMxMjj4izFF" colab={"base_uri": "https://localhost:8080/", "height": 452} executionInfo={"status": "ok", "timestamp": 1605692316429, "user_tz": 0, "elapsed": 458, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="ed4f0178-2b5c-45c5-b083-32c0c665f215"
#hide_input
germany
# + [markdown] id="znd4zFjWmtvR"
# Germany did make some substitutions however, bringing their best penalty taker Thomas Häßler on in normal time in addition to Marco Bode and Thomas Strunz in extra time. Whilst Bode (a winger) looks worse than average at penalties he was subbed on for a centre-back in an attempt to win the game in extra-time, and he wasn't chosen as one of the top six options in the shootout. It's interesting that Thomas Strunz was brought on to take the second penalty in favour of Oliver Bierhoff (who scored twice in the final), since our estimate is that Bierhoff is below average from the spot. Maybe the coaches were onto something... Captain Andreas Möller scored the winning penalty in sudden-death, but it looks like he was probably a below average penalty taker also.
#
# > Note: Just a reminder that I'm still ignoring goalkeeper skill, but [Andreas Köpke saved 22/84 penalties in his career](https://www.transfermarkt.com/andreas-kopke/elfmeterstatistik/spieler/1445), so maybe it's harder to score against him than a typical goalie!
# + id="1RW31sxXYqAb" executionInfo={"status": "ok", "timestamp": 1605692318139, "user_tz": 0, "elapsed": 438, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}}
#collapse-hide
# Remove unwanted players
fowler = england.copy()[england['name']=='Robbie Fowler']
england = england.copy()[england['name']!='Robbie Fowler']
germany = germany.copy()[~germany['name'].isin(['Mehmet Scholl', 'Oliver Bierhoff'])]
# Order the players to get Platt taking the second penalty etc
# We only know the first six players for each team, so assume the order for the rest
england['order'] = [1,5,3,7,2,4,8,9,6,10,11]
england = england.copy().sort_values('order')
germany['order'] = [1,5,7,8,2,9,10,4,11,6,3]
germany = germany.copy().sort_values('order')
# + [markdown] id="0wRGsRV4wqeP"
# We can see which team is expected to win the shootout by simulating it using the predicted conversion rates for each player to determine whether they scored or missed their penalty. Here is one simulation:
# + id="J3UHzEMGkpx7" colab={"base_uri": "https://localhost:8080/"} executionInfo={"status": "ok", "timestamp": 1605692319629, "user_tz": 0, "elapsed": 418, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="6030368b-cb0e-4004-e265-909d5ed06f2d"
#collapse-hide
def shootout(team_a, team_b, printer=False):
"""Function to simulate a penalty shootout. Takes two dataframes as input, one for each team.
The dataframe should be sorted in the order used for the shootout, i.e. the
first player to take a penalty should be at row 1, the second at row 2 etc.
"""
a_score = 0
b_score = 0
a_wins = 0
b_wins = 0
a_index = 0
b_index = 0
# df index should be from 0 to len(df)
team_a = team_a.reset_index().drop('index', axis=1)
team_b = team_b.reset_index().drop('index', axis=1)
while a_wins == b_wins:
# Reset index to 0 if every player has taken a penalty in this round
if a_index > len(team_a)-1:
a_index = 0
if b_index > len(team_b)-1:
b_index = 0
# Get Team A result
a_player = team_a.iloc[a_index, 0]
a_prob = team_a.iloc[a_index, 4]
a_result = np.random.choice([0,1], 1, p=[1-a_prob, a_prob])
a_score += a_result
if printer != False:
print(a_player+'...scores! (%d-%d)' % (a_score, b_score) if a_result ==1 else a_player+'...misses! (%d-%d)' % (a_score, b_score))
# Get Team B result
b_player = team_b.iloc[a_index, 0]
b_prob = team_b.iloc[a_index, 4]
b_result = np.random.choice([0,1], 1, p=[1-a_prob, a_prob])
b_score += b_result
if printer != False:
print(b_player+'...scores! (%d-%d)' % (a_score, b_score) if b_result ==1 else b_player+'...misses! (%d-%d)' % (a_score, b_score))
a_index += 1
b_index += 1
# Stop the shootout when scores are no longer equal and at least five penalties each have been taken
if (a_index >= 5):
if (a_score > b_score):
a_wins += 1
if printer != False:
print('\nTeam A wins! (%d-%d)' % (a_score, b_score))
elif (a_score < b_score):
b_wins += 1
if printer != False:
print('\nTeam B wins! (%d-%d)' % (b_score, a_score))
return a_wins, b_wins
# Run one penalty shootout
_, _ = shootout(england, germany, printer=True)
# + [markdown] id="s0l-fTtEXFz9"
# Let's run this thousands of times and calculate how often England would be expected to advance to the final:
# + id="g-tK9b-MFORE" colab={"base_uri": "https://localhost:8080/"} executionInfo={"status": "ok", "timestamp": 1605692518173, "user_tz": 0, "elapsed": 22148, "user": {"displayName": "Tom Whelan", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgnbPvaiz9OgiXkVoVkd2gHC3Jpjk3NZsn-eoSH=s64", "userId": "03831464729329717576"}} outputId="cb9ec34c-4aba-49d9-8d49-e8965024a206"
#collapse-hide
num_sims = 5000
def simulate_shootouts(team_a, team_b, num_sims):
a_wins = 0
b_wins = 0
for i in range(num_sims):
a, b = shootout(team_a, team_b)
a_wins += a
b_wins += b
return a_wins, b_wins
eng_wins, ger_wins = simulate_shootouts(england, germany, num_sims)
eng_win_pct = str(round((eng_wins/num_sims)*100, 1))
print('England win probability = %s' % (eng_win_pct+'%'))
# + [markdown] id="4hkzgTDWWZ6s"
# Pretty close, but a loss wasn't inevitable at least! Unless you believe in curses, that is...
# + [markdown] id="lK8HGg0fUUOy"
# # Conclusion
# Thanks for reading! I hope you enjoyed this and learned something useful. We could have made a much more complicated model of penalty taking skill, but as discussed earlier extra complexity wouldn't necessarily be better here. By using empirical Bayes estimation we were able to get some interesting insights out of a limited dataset in just a few steps. If you want to explore this topic further you could use the same process to estimate penalty save percentage, or you could try to improve on this model. A couple of ways to do that would be to [use more data](https://fbref.com/en/about/coverage) or estimate different priors for different groups of players, e.g. should the prior distribution for a team's main penalty taker be the same as the prior for someone who was only trusted to take a handful of penalties in their career? Let me know what you find out!
#
# Thanks again to David Robinson, whose work make this possible, and to FBRef and Transfermarkt for the data.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Celsius and Fahrenheit Intersection
#
# There are two common [temperature](https://en.wikipedia.org/wiki/Temperature) scales, [Celsius](https://en.wikipedia.org/wiki/Celsius) and [Fahrenheit](https://en.wikipedia.org/wiki/Fahrenheit) (as well as [Kelvin](https://en.wikipedia.org/wiki/Kelvin) and [Rankine](https://en.wikipedia.org/wiki/Rankine_scale) that we won't talk about today).
#
# I've heard that these two scales intersect at a particular temperature. Let's find that temperature.
#
# First we'll create a couple of functions to convert from one to another.
# +
def celsius_to_fahrenheit(c):
f = c * (9/5) + 32
return f
def fahrenheit_to_celsius(f):
c = (f - 32) * (5/9)
return c
# -
# Then use those functions to convert temperatures.
print(celsius_to_fahrenheit(20))
print(fahrenheit_to_celsius(68))
# Create a dataframe of values in Celsius and their Fahrenheit equivalents.
# +
import pandas as pd
import numpy as np
celsius_values = np.arange(-273, 150, 1)
fahrenheit_values = celsius_to_fahrenheit(celsius_values)
data = {'Celsius':celsius_values, 'Fahrenheit':fahrenheit_values}
temperatures = pd.DataFrame(data)
temperatures.tail()
# -
# Graph the Celsius and Fahrenheit values.
import cufflinks as cf
cf.go_offline()
# If you are using Colab
def enable_plotly_in_cell():
import IPython
from plotly.offline import init_notebook_mode
display(IPython.core.display.HTML('''<script src="/static/components/requirejs/require.js"></script>'''))
init_notebook_mode(connected=False)
get_ipython().events.register('pre_run_cell', enable_plotly_in_cell)
print('Interactive plotting enabled')
temperatures.iplot()
# It looks like the lines cross at a value around -40 degrees. To verify, select the row from the dataframe that we think corresponds to the matching temperature.
temperatures[temperatures['Celsius'] == -40]
# We found that the Celsius and Fahrenheit temperature scales intersect at -40 degrees.
#
# That's pretty cold. But as they say in Scandinavian countries, "There's no bad weather, only bad clothes" (which apparently rhymes in both Norwegian and Swedish).
#
# Just for fun, let's translate that phrase using Google Translate and then have the computer speak the translation using Google text-to-speech.
#
# *Thanks to [Rajan Patel](https://github.com/rgpatel) for the googletrans and gTTS ideas.*
# !pip install --user googletrans
# !pip install --user gTTS
from googletrans import Translator
tran = Translator()
import gtts
from IPython.display import Audio, display
phrase = 'No bad weather, just bad clothes'
# +
norwegian = 'no'
norwegian_translation = tran.translate(phrase, dest=norwegian).extra_data['translation'][0][0]
print(norwegian_translation)
norwegian_text_to_speech = gtts.gTTS(norwegian_translation, lang=norwegian)
norwegian_text_to_speech.save('norwegian.mp3')
display(Audio('norwegian.mp3'))
# +
swedish = 'sv'
swedish_translation = tran.translate(phrase, dest=swedish).extra_data['translation'][0][0]
print(swedish_translation)
swedish_text_to_speech = gtts.gTTS(swedish_translation, lang=swedish)
swedish_text_to_speech.save('swedish.mp3')
display(Audio('swedish.mp3'))
|
# ---
# jupyter:
# jupytext:
# formats: ipynb,.pct.py:percent
# text_representation:
# extension: .py
# format_name: percent
# format_version: '1.3'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# %% [markdown]
# # Convolutional Gaussian Processes
# Mark van der Wilk (July 2019)
#
# Here we show a simple example of the rectangles experiment, where we compare a normal squared exponential GP, and a convolutional GP. This is similar to the experiment in [1].
#
# [1] Van der Wilk, Rasmussen, Hensman (2017). Convolutional Gaussian Processes. *Advances in Neural Information Processing Systems 30*.
# %% [markdown]
# ## Generate dataset
# Generate a simple dataset of rectangles. We want to classify whether they are tall or wide. **NOTE:** Here we take care to make sure that the rectangles don't touch the edge, which is different to the original paper. We do this to avoid needing to use patch weights, which are needed to correctly account for edge effects.
# %%
import time
import numpy as np
import matplotlib.pyplot as plt
import gpflow
import tensorflow as tf
import tensorflow_probability as tfp
from gpflow import set_trainable
from gpflow.ci_utils import is_continuous_integration
gpflow.config.set_default_float(np.float64)
gpflow.config.set_default_jitter(1e-4)
gpflow.config.set_default_summary_fmt("notebook")
# for reproducibility of this notebook:
np.random.seed(123)
tf.random.set_seed(42)
MAXITER = 2 if is_continuous_integration() else 100
NUM_TRAIN_DATA = (
5 if is_continuous_integration() else 100
) # This is less than in the original rectangles dataset
NUM_TEST_DATA = 7 if is_continuous_integration() else 300
H = W = 14 # width and height. In the original paper this is 28
IMAGE_SHAPE = [H, W]
# %%
def make_rectangle(arr, x0, y0, x1, y1):
arr[y0:y1, x0] = 1
arr[y0:y1, x1] = 1
arr[y0, x0:x1] = 1
arr[y1, x0 : x1 + 1] = 1
def make_random_rectangle(arr):
x0 = np.random.randint(1, arr.shape[1] - 3)
y0 = np.random.randint(1, arr.shape[0] - 3)
x1 = np.random.randint(x0 + 2, arr.shape[1] - 1)
y1 = np.random.randint(y0 + 2, arr.shape[0] - 1)
make_rectangle(arr, x0, y0, x1, y1)
return x0, y0, x1, y1
def make_rectangles_dataset(num, w, h):
d, Y = np.zeros((num, h, w)), np.zeros((num, 1))
for i, img in enumerate(d):
for j in range(1000): # Finite number of tries
x0, y0, x1, y1 = make_random_rectangle(img)
rw, rh = y1 - y0, x1 - x0
if rw == rh:
img[:, :] = 0
continue
Y[i, 0] = rw > rh
break
return (
d.reshape(num, w * h).astype(gpflow.config.default_float()),
Y.astype(gpflow.config.default_float()),
)
# %%
X, Y = data = make_rectangles_dataset(NUM_TRAIN_DATA, *IMAGE_SHAPE)
Xt, Yt = test_data = make_rectangles_dataset(NUM_TEST_DATA, *IMAGE_SHAPE)
# %%
plt.figure(figsize=(8, 3))
for i in range(4):
plt.subplot(1, 4, i + 1)
plt.imshow(X[i, :].reshape(*IMAGE_SHAPE))
plt.title(Y[i, 0])
# %% [markdown]
# ## Squared Exponential kernel
# %%
rbf_m = gpflow.models.SVGP(
gpflow.kernels.SquaredExponential(),
gpflow.likelihoods.Bernoulli(),
gpflow.inducing_variables.InducingPoints(X.copy()),
)
# %%
rbf_training_loss_closure = rbf_m.training_loss_closure(data, compile=True)
rbf_elbo = lambda: -rbf_training_loss_closure().numpy()
print("RBF elbo before training: %.4e" % rbf_elbo())
# %%
set_trainable(rbf_m.inducing_variable, False)
start_time = time.time()
res = gpflow.optimizers.Scipy().minimize(
rbf_training_loss_closure,
variables=rbf_m.trainable_variables,
method="l-bfgs-b",
options={"disp": True, "maxiter": MAXITER},
)
print(f"{res.nfev / (time.time() - start_time):.3f} iter/s")
# %%
train_acc = np.mean((rbf_m.predict_y(X)[0] > 0.5).numpy().astype("float") == Y)
test_acc = np.mean((rbf_m.predict_y(Xt)[0] > 0.5).numpy().astype("float") == Yt)
print(f"Train acc: {train_acc * 100}%\nTest acc : {test_acc*100}%")
print("RBF elbo after training: %.4e" % rbf_elbo())
# %% [markdown]
# ## Convolutional kernel
# %%
f64 = lambda x: np.array(x, dtype=np.float64)
positive_with_min = lambda: tfp.bijectors.AffineScalar(shift=f64(1e-4))(tfp.bijectors.Softplus())
constrained = lambda: tfp.bijectors.AffineScalar(shift=f64(1e-4), scale=f64(100.0))(
tfp.bijectors.Sigmoid()
)
max_abs_1 = lambda: tfp.bijectors.AffineScalar(shift=f64(-2.0), scale=f64(4.0))(
tfp.bijectors.Sigmoid()
)
patch_shape = [3, 3]
conv_k = gpflow.kernels.Convolutional(gpflow.kernels.SquaredExponential(), IMAGE_SHAPE, patch_shape)
conv_k.base_kernel.lengthscales = gpflow.Parameter(1.0, transform=positive_with_min())
# Weight scale and variance are non-identifiable. We also need to prevent variance from shooting off crazily.
conv_k.base_kernel.variance = gpflow.Parameter(1.0, transform=constrained())
conv_k.weights = gpflow.Parameter(conv_k.weights.numpy(), transform=max_abs_1())
conv_f = gpflow.inducing_variables.InducingPatches(
np.unique(conv_k.get_patches(X).numpy().reshape(-1, 9), axis=0)
)
# %%
conv_m = gpflow.models.SVGP(conv_k, gpflow.likelihoods.Bernoulli(), conv_f)
# %%
set_trainable(conv_m.inducing_variable, False)
set_trainable(conv_m.kernel.base_kernel.variance, False)
set_trainable(conv_m.kernel.weights, False)
# %%
conv_training_loss_closure = conv_m.training_loss_closure(data, compile=True)
conv_elbo = lambda: -conv_training_loss_closure().numpy()
print("conv elbo before training: %.4e" % conv_elbo())
# %%
start_time = time.time()
res = gpflow.optimizers.Scipy().minimize(
conv_training_loss_closure,
variables=conv_m.trainable_variables,
method="l-bfgs-b",
options={"disp": True, "maxiter": MAXITER / 10},
)
print(f"{res.nfev / (time.time() - start_time):.3f} iter/s")
# %%
set_trainable(conv_m.kernel.base_kernel.variance, True)
res = gpflow.optimizers.Scipy().minimize(
conv_training_loss_closure,
variables=conv_m.trainable_variables,
method="l-bfgs-b",
options={"disp": True, "maxiter": MAXITER},
)
train_acc = np.mean((conv_m.predict_y(X)[0] > 0.5).numpy().astype("float") == Y)
test_acc = np.mean((conv_m.predict_y(Xt)[0] > 0.5).numpy().astype("float") == Yt)
print(f"Train acc: {train_acc * 100}%\nTest acc : {test_acc*100}%")
print("conv elbo after training: %.4e" % conv_elbo())
# %%
res = gpflow.optimizers.Scipy().minimize(
conv_training_loss_closure,
variables=conv_m.trainable_variables,
method="l-bfgs-b",
options={"disp": True, "maxiter": MAXITER},
)
train_acc = np.mean((conv_m.predict_y(X)[0] > 0.5).numpy().astype("float") == Y)
test_acc = np.mean((conv_m.predict_y(Xt)[0] > 0.5).numpy().astype("float") == Yt)
print(f"Train acc: {train_acc * 100}%\nTest acc : {test_acc*100}%")
print("conv elbo after training: %.4e" % conv_elbo())
# %%
set_trainable(conv_m.kernel.weights, True)
res = gpflow.optimizers.Scipy().minimize(
conv_training_loss_closure,
variables=conv_m.trainable_variables,
method="l-bfgs-b",
options={"disp": True, "maxiter": MAXITER},
)
train_acc = np.mean((conv_m.predict_y(X)[0] > 0.5).numpy().astype("float") == Y)
test_acc = np.mean((conv_m.predict_y(Xt)[0] > 0.5).numpy().astype("float") == Yt)
print(f"Train acc: {train_acc * 100}%\nTest acc : {test_acc*100}%")
print("conv elbo after training: %.4e" % conv_elbo())
# %%
gpflow.utilities.print_summary(rbf_m)
# %%
gpflow.utilities.print_summary(conv_m)
# %% [markdown]
# ## Conclusion
# The convolutional kernel performs much better in this simple task. It demonstrates non-local generalization of the strong assumptions in the kernel.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="ZGYN8XySCKSt" colab_type="text"
# # CNN electronic music label classification full-track chunk
# + [markdown] id="Mm3HTWugkLvi" colab_type="text"
# ### Import libraries
# + id="I09P9JUjCKSw" colab_type="code" colab={}
import torch
import torch.nn as nn
import numpy as np
import pandas as pd
from torch.utils import data
import os
import tqdm as tqdm
import matplotlib.pyplot as plt
# + id="5B553TpuCRHS" colab_type="code" outputId="1d3fea96-e7f2-4ff9-e71b-8cd64d675d80" colab={"base_uri": "https://localhost:8080/", "height": 122}
from google.colab import drive
drive.mount('/content/drive')
# + [markdown] id="WZWrB6y9CKSz" colab_type="text"
# ### Class definition
# Dataset and CNN
# + id="BgM3VrntCKS0" colab_type="code" colab={}
class AudioFolder(data.Dataset):
def __init__(self, csv_path, labels):
self.csv = pd.read_csv(csv_path)
self.labels = labels
self.output_dict = dict()
for i,l in enumerate(self.labels):
self.output_dict[l]=i
def __getitem__(self, index):
npy, label = self.get_npy(index)
return npy.astype('float'), label
def get_npy(self, index):
path = self.csv['path'][index]
path = path.split('/homedtic/jbustos/mel_specs/')[1]
path = '/content/drive/My Drive/archives/mel_specs/'+path
npy = np.load(path)
#Hot encoding output
#label_hot = np.zeros(len(labels))
label = self.output_dict[self.csv['label'][index]]
#label_hot[label]=1
return npy, label
def __len__(self):
return len(self.csv)
def my_collate(batch):
min_size = min([item[0].shape[1] for item in batch])
data = [item[0][:,:min_size] for item in batch]
target = [item[1] for item in batch]
data = torch.Tensor(data)
target = torch.LongTensor(target)
return [data, target]
def get_audio_loader():
data_loader = data.DataLoader(dataset=AudioFolder(csv_path=csv_path, labels=labels),
batch_size=batch_size,
shuffle=True,
collate_fn=my_collate,
drop_last=False)
return data_loader
# + id="IVuadrKZCKS3" colab_type="code" colab={}
class CNN(nn.Module):
def __init__(self, gap_h, gap_w, num_class=9):
super(CNN, self).__init__()
# init bn
self.bn_init = nn.BatchNorm2d(1)
# layer 1
self.conv_1 = nn.Conv2d(1, 64, 3, padding=1)
self.bn_1 = nn.BatchNorm2d(64)
self.mp_1 = nn.MaxPool2d((2, 4))
# layer 2
self.conv_2 = nn.Conv2d(64, 128, 3, padding=1)
self.bn_2 = nn.BatchNorm2d(128)
self.mp_2 = nn.MaxPool2d((2, 4))
# layer 3
self.conv_3 = nn.Conv2d(128, 128, 3, padding=1)
self.bn_3 = nn.BatchNorm2d(128)
self.mp_3 = nn.MaxPool2d((2, 4))
# layer 4
self.conv_4 = nn.Conv2d(128, 128, 3, padding=1)
self.bn_4 = nn.BatchNorm2d(128)
self.mp_4 = nn.MaxPool2d((3, 5))
# layer 5
self.conv_5 = nn.Conv2d(128, 64, 3, padding=1)
self.bn_5 = nn.BatchNorm2d(64)
self.mp_5 = nn.MaxPool2d((4, 4))
# classifier
self.dense = nn.Linear(64, num_class)
def forward(self, x):
x = x.unsqueeze(1)
# init bn
x = self.bn_init(x)
# layer 1
x = self.mp_1(nn.ELU()(self.bn_1(self.conv_1(x))))
# layer 2
x = self.mp_2(nn.ELU()(self.bn_2(self.conv_2(x))))
# layer 3
x = self.mp_3(nn.ELU()(self.bn_3(self.conv_3(x))))
# layer 4
x = self.mp_4(nn.ELU()(self.bn_4(self.conv_4(x))))
# layer 5
x = self.mp_5(nn.ELU()(self.bn_5(self.conv_5(x))))
gap = nn.AvgPool2d((1, x.size(3)), stride=(1, 1))
x = gap(x)
# classifier
x = x.view(x.size(0), -1)
x = nn.Dropout(0.5)(x)
logit = self.dense(x)
return logit
# + [markdown] id="JMmaV-NJCKS8" colab_type="text"
# Reading labels
# + id="gwZdp_t7CKS8" colab_type="code" outputId="0f5b8fe6-07e7-4c02-b581-b04d5d8d71e6" colab={"base_uri": "https://localhost:8080/", "height": 207}
count = 0
count_songs = 0
labels = []
labels_dict = dict()
main_dir = '/content/drive/My Drive/archives/mel_specs/complete_track/train'
for root, dirs, files in os.walk (main_dir):
count += 1
if count==1:
labels = [label for label in dirs if not label.startswith('.')]
else:
break
print(labels)
for l in labels:
count = 0
for root, dirs, files in os.walk(main_dir+'/'+l):
for file in files:
count+=1
print(l,' = ',count)
# + [markdown] id="pcQ9-c0UkfWv" colab_type="text"
# ### Initialization dataset, model, criterion and optimizer
# + [markdown] id="ZwF2b41Fk12N" colab_type="text"
# Train and set DataLoader initialization
# + id="mnjRhKZbCKTD" colab_type="code" colab={}
csv_path = '/content/drive/My Drive/archives/mel_specs/complete_track/train_complete.csv'
batch_size = 4
train_loader = get_audio_loader()
csv_path = '/content/drive/My Drive/archives/mel_specs/complete_track/test_complete.csv'
batch_size = 4
test_loader = get_audio_loader()
# + [markdown] id="HE5CxT5pk3RG" colab_type="text"
# Model, criterion and optimizer initialization
# + id="DJm7AwAkbI2t" colab_type="code" colab={}
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
nn.init.xavier_normal_(m.weight.data)
# + id="nYzDpjZECKTG" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 340} outputId="5c999657-9347-432c-ce77-2ce7bb3906ca"
torch.manual_seed(42)
device = torch.device('cuda')
model = CNN(num_class=9, gap_h=1, gap_w=2)
model.cuda(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), 2e-4)
model.apply(weights_init)
# + [markdown] id="uaf5kK2Wk9Fm" colab_type="text"
# Loading checkpoint
# + id="tEanQeP3syBN" colab_type="code" outputId="33ed9e11-29cb-40ab-a2c6-d7142c26248e" colab={"base_uri": "https://localhost:8080/", "height": 340}
checkpoint = torch.load('/content/drive/My Drive/archives/mel_specs/complete_track/checkpointjbf.tar', map_location='cpu')
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
cost_list = checkpoint['cost_list']
model.cuda()
# + [markdown] id="aDdVptpYlDGv" colab_type="text"
# ### Training
# + id="fa6_gmjYYLDT" colab_type="code" colab={}
cost_list = []
#pred_list = []
epoch = 0
COST=0
# + id="jbs5_aj0CKTJ" colab_type="code" outputId="4cb23b1a-0fe0-48ca-d4c2-5265a51b759a" colab={"base_uri": "https://localhost:8080/", "height": 1000}
for epoch in tqdm.tqdm(range(epoch,200)):
COST=0
model.train()
for i,data in enumerate(train_loader):
x,y = data
x = x.to(device)
y = y.to(device)
optimizer.zero_grad()
y_=model(x)
loss=criterion(y_,y)
loss.backward()
optimizer.step()
COST+=loss.data
if i % 50 == 0:
print(loss)
cost_list.append(COST)
print('COST epoch',epoch, ' = ', cost_list)
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': COST,
'cost_list': cost_list,
}, '/content/drive/My Drive/archives/mel_specs/complete_track/checkpointjbf.tar')
model.eval()
y_list = []
pred_list = []
for i, data in enumerate(test_loader):
x, y = data
x = x.cuda()
pred = model(x)
# append
pred = pred.detach().cpu()
for _p in pred:
pred_list.append(int(_p.argmax()))
for _y in y:
y_list.append(int(_y))
if i % 10 == 0:
print('Files processed = ', i)
print(pred_list)
print(y_list)
accuracy = np.sum(np.asarray(pred_list)==np.asarray(y_list))/len(y_list)
print('Accuracy epoch',epoch, ' = ',accuracy)
# + id="wp3qvwwSCKTN" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 282} outputId="6c12a313-8e78-4303-9fa1-8702918da6e8"
plt.plot(cost_list)
# + [markdown] id="ytItCcLoCKTQ" colab_type="text"
# ### Evaluation
# + [markdown] id="-Ih6AitSlIFT" colab_type="text"
# Model loading
# + id="IWBI0zkeCKTR" colab_type="code" outputId="1e6c46b5-ffc5-4ef0-b77e-9b0bae367428" colab={"base_uri": "https://localhost:8080/", "height": 355}
device = torch.device('cuda')
model = CNN(num_class=9, gap_h=1, gap_w=2)
checkpoint = torch.load('/content/drive/My Drive/complete_track/checkpoint>50.tar', map_location=lambda storage, loc: storage)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
model.cuda()
# + id="1f41FpLJCKTT" colab_type="code" outputId="38d22d13-eb2e-47df-ea6f-0c04fea23bd0" colab={"base_uri": "https://localhost:8080/", "height": 355}
y_list = []
pred_list = []
model.eval()
for i, data in enumerate(test_loader):
x, y = data
x = x.cuda()
pred = model(x)
pred = pred.detach().cpu()
for _p in pred:
pred_list.append(int(_p.argmax()))
for _y in y:
y_list.append(int(_y))
if i % 10 == 0:
print('Files processed = ', i)
# + [markdown] id="7PkreAUslelJ" colab_type="text"
# Accuracy calculation
# + id="kntV0jeTCKTY" colab_type="code" outputId="d24a31eb-62b2-4adf-80d5-9b008e114b95" colab={"base_uri": "https://localhost:8080/", "height": 35}
accuracy = np.sum(np.asarray(pred_list)==np.asarray(y_list))/len(y_list)
print(accuracy)
# + [markdown] id="gnVMUaEdlgaz" colab_type="text"
# Confusion matrix calculation
# + id="gDCrUpFiCKTb" colab_type="code" outputId="5f468b35-b197-4dfa-c9a2-9747b0ecb01e" colab={"base_uri": "https://localhost:8080/", "height": 349}
import sklearn.metrics
import seaborn
lab = [lab.split('archive')[0] for lab in labels]
plt.figure()
plt.title('Confusion matrix full-track chunk')
cm = sklearn.metrics.confusion_matrix(np.asarray(y_list), np.asarray(pred_list))
seaborn.heatmap(cm, annot=True, xticklabels=lab, yticklabels=lab, fmt="d", cmap = "Oranges")
# + [markdown] id="d6WUbj8mlk2m" colab_type="text"
# F1 score calculation
# + id="DjeUifEtCKTj" colab_type="code" outputId="80a94ccd-b514-4171-e196-9ba84347d163" colab={"base_uri": "https://localhost:8080/", "height": 35}
sklearn.metrics.f1_score(y_list, pred_list, average='micro')
# + [markdown] id="Q9vEI-aT1YBO" colab_type="text"
# # Further analysis
# + [markdown] id="VA9PdWjFlqBF" colab_type="text"
# In this part we analyze train data set accuracy to check if model is overfitting
# + id="eAYBJ2-R1aRP" colab_type="code" outputId="9f09c718-6381-4939-ff89-5d00e3eb9e0a" colab={"base_uri": "https://localhost:8080/", "height": 1000}
y_list = []
pred_list = []
model.eval()
for i, data in enumerate(train_loader):
x, y = data
x = x.cuda()
pred = model(x)
pred = pred.detach().cpu()
for _p in pred:
pred_list.append(int(_p.argmax()))
for _y in y:
y_list.append(int(_y))
if i % 10 == 0:
print('Files processed = ', i)
# + [markdown] id="kqWI0frulvri" colab_type="text"
# Accuracy calculation
# + id="LlsGeM3A1b7M" colab_type="code" outputId="56e77e2b-f020-4e9f-9344-193c008a02aa" colab={"base_uri": "https://localhost:8080/", "height": 35}
accuracy = np.sum(np.asarray(pred_list)==np.asarray(y_list))/len(y_list)
print(accuracy)
# + [markdown] id="IF3dsz5klw-4" colab_type="text"
# We see how the accuracy for training set is very high while test set accuracy is low. This shows that our model is overfitting
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Psych 81.09
# language: python
# name: psych81.09
# ---
# +
#Imported relevant and necessary libraries and data cleaning tools
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import hypertools as hyp
from glob import glob as lsdir
import os
import re
import datetime as dt
from sklearn import linear_model
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split
# %matplotlib inline
# +
#Code from Professor Manning to set up and read in the relevant UVLT data
data_readers = {'xlsx': pd.read_excel, 'xls': pd.read_excel, 'dta': pd.read_stata}
get_extension = lambda x: x.split('.')[-1]
def read_data(datadir, readers):
files = lsdir(os.path.join(datadir, '*'))
readable_files = []
data = []
for f in files:
ext = get_extension(f)
if ext in readers.keys():
readable_files.append(f)
data.append(data_readers[ext](f))
return readable_files, data
fnames, data = read_data('data', data_readers)
# -
#A summary of the data files that are now read into the notebook
fnames
#This is the individual data
#Most of the initial cleaning that I have done has been on this data set, though obviously it can be applied if necessary to any of the data sets
data[0].head()
#Renaming relevant columns in UVLT individual data to be more easily readable
names={'DeceasedDateYN' : 'Is the donor Deceased?',
'U_Tot_Amt': 'Total Unrestricted Donations',
'U_Tot_Cnt': 'Total Number of Unrestricted Donations Given',
'ConservedOwner' : 'Owns Conserved Land?',
'RTotAmt' : 'Total Restricted Donations',
'RTotCnt': 'Total Number of Restricted Donations Given',
'VTotCnt' : 'Total Volunteer Occurances',
'ETotCnt' : 'Total Event Attendances'}
data[0].rename(names, inplace=True, axis=1)
#Summary of the column values in data set 1
data[0].columns.values
# +
#copying each set of data into more memorably named versions
#I figured different analyses require different aspects of each dataframe, so starting here and using copies of the data for different analyses may be helpful for organizationa and fidelity
Individual_data=data[0].copy()
Final_data=data[1].copy()
Mailing_data=data[2].copy()
Town_Data=data[5].copy()
#Similarly to the individual data, the final data could benefit from some cleaner column names
Final_data.rename(names, inplace=True, axis=1)
# +
to_drop={'U200001',
'U200102',
'U200203',
'U200304',
'U200405',
'U200506',
'U200607',
'U200708',
'U200809',
'U200910',
'U201011',
'U201112',
'U201213',
'U201314',
'U201415',
'U201516',
'U201617',
'U201718',
'U201819',
'R200001',
'R200102',
'R200203',
'R200304',
'R200405',
'R200506',
'R200607',
'R200708',
'R200809',
'R200910',
'R201011',
'R201112',
'R201213',
'R201314',
'R201415',
'R201516',
'R201617',
'R201718',
'R201819',
'V200001',
'V200102',
'V200203',
'V200304',
'V200405',
'V200506',
'V200607',
'V200708',
'V200809',
'V200910',
'V201011',
'V201112',
'V201213',
'V201314',
'V201415',
'V201516',
'V201617',
'V201718',
'V201819',
'E200001',
'E200102',
'E200203',
'E200304',
'E200405',
'E200506',
'E200607',
'E200708',
'E200809',
'E200910',
'E201011',
'E201112',
'E201213',
'E201314',
'E201415',
'E201516',
'E201617',
'E201718',
'E201819'}
Individual_data_SUMMARY=data[0].copy()
# -
Individual_data_SUMMARY.drop(to_drop, inplace=True, axis=1)
#The summary cleaning gets rid of the year-by-year data and leaves only the summary of the donations for analyses
#obviously there are pros and cons to this, but I figured it was a tedious process to undertake so now it's a simple dictionary that can be used on the various data sets
Individual_data_SUMMARY.head(15)
Final_data_SUMMARY=Final_data.copy()
Final_data_SUMMARY.drop(to_drop, inplace=True, axis=1)
Final_data_SUMMARY.head(15)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] papermill={"duration": 0.018787, "end_time": "2021-05-05T14:17:11.814864", "exception": false, "start_time": "2021-05-05T14:17:11.796077", "status": "completed"} tags=[]
# # Imports
# + _cell_guid="b1076dfc-b9ad-4769-8c92-a6c4dae69d19" _uuid="8f2839f25d086af736a60e9eeb907d3b93b6e0e5" papermill={"duration": 14.540492, "end_time": "2021-05-05T14:17:26.373901", "exception": false, "start_time": "2021-05-05T14:17:11.833409", "status": "completed"} tags=[]
# !pip install -q efficientnet
import efficientnet.tfkeras as efn
import os, pickle
import pandas as pd
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from math import log
from numpy import array
from numpy import argmax
# + papermill={"duration": 0.040614, "end_time": "2021-05-05T14:17:26.433130", "exception": false, "start_time": "2021-05-05T14:17:26.392516", "status": "completed"} tags=[]
# seed everything
SEED = 4546
os.environ['PYTHONHASHSEED'] = str(SEED)
np.random.seed(SEED)
tf.random.set_seed(SEED)
TPU= False
# image resolution
IMG_HEIGHT = 256
IMG_WIDTH = 448
N_CHANNELS = 3
# maximum InChI length is 200 to prevent too much padding
MAX_INCHI_LEN = 200
BATCH_SIZE= 30
# ImageNet mean and std to normalize training images accordingly
IMAGENET_MEAN = tf.constant([0.485, 0.456, 0.406], dtype=tf.float32)
IMAGENET_STD = tf.constant([0.229, 0.224, 0.225], dtype=tf.float32)
# + [markdown] papermill={"duration": 0.018037, "end_time": "2021-05-05T14:17:26.468825", "exception": false, "start_time": "2021-05-05T14:17:26.450788", "status": "completed"} tags=[]
# # Data Pipeline
# + papermill={"duration": 0.046817, "end_time": "2021-05-05T14:17:26.538989", "exception": false, "start_time": "2021-05-05T14:17:26.492172", "status": "completed"} tags=[]
# dictionary to translate a character to the integer encoding
with open('../input/bmstfrecord-data/vocabulary_to_int.pkl', 'rb') as p:
vocabulary_to_int= pickle.load(p)
# dictionary to decode an integer encoded character back to the character
with open('../input/bmstfrecord-data/int_to_vocabulary.pkl', 'rb') as p:
int_to_vocabulary= pickle.load(p)
# + papermill={"duration": 0.02855, "end_time": "2021-05-05T14:17:26.588612", "exception": false, "start_time": "2021-05-05T14:17:26.560062", "status": "completed"} tags=[]
START_TOKEN = tf.constant(vocabulary_to_int.get('<start>'), dtype=tf.int64)
END_TOKEN = tf.constant(vocabulary_to_int.get('<end>'), dtype=tf.int64)
PAD_TOKEN = tf.constant(vocabulary_to_int.get('<pad>'), dtype=tf.int64)
# + papermill={"duration": 0.246126, "end_time": "2021-05-05T14:17:26.852675", "exception": false, "start_time": "2021-05-05T14:17:26.606549", "status": "completed"} tags=[]
def decode_tfrecord(record_bytes):
feature= tf.io.parse_single_example(record_bytes,{
'image': tf.io.FixedLenFeature([], tf.string),
'InChI': tf.io.FixedLenFeature([MAX_INCHI_LEN], tf.int64)
})
# decode the PNG and explicitly reshape to image size (required on TPU)
image = tf.io.decode_png(feature['image'])
image = tf.reshape(image, [IMG_HEIGHT, IMG_WIDTH, 1])
# normalize according to ImageNet mean and std
image = tf.cast(image, tf.float32) / 255.0
image = (image - IMAGENET_MEAN) / IMAGENET_STD
if TPU: # if running on TPU image needs to be cast to bfloat16
image = tf.cast(image, TARGET_DTYPE)
InChI = tf.reshape(feature['InChI'], [MAX_INCHI_LEN])
InChI = tf.cast(InChI, tf.uint8)
#InChI= tf.one_hot(InChI, depth= 41)
return image, InChI
def get_val_dataset(bs=BATCH_SIZE):
FNAMES_TRAIN_TFRECORDS = tf.io.gfile.glob('../input/bmstfrecord-data/val/*.tfrecords')
AUTO= tf.data.experimental.AUTOTUNE
val_dataset = tf.data.TFRecordDataset(FNAMES_TRAIN_TFRECORDS, num_parallel_reads=AUTO)
val_dataset = val_dataset.prefetch(AUTO)
val_dataset = val_dataset.repeat()
val_dataset = val_dataset.map(decode_tfrecord, num_parallel_calls=AUTO)
val_dataset = val_dataset.batch(BATCH_SIZE, drop_remainder=True)
val_dataset = val_dataset.prefetch(1)
return val_dataset
val_dataset = get_val_dataset()
# + papermill={"duration": 0.241831, "end_time": "2021-05-05T14:17:27.112893", "exception": false, "start_time": "2021-05-05T14:17:26.871062", "status": "completed"} tags=[]
imgs, lbls = next(iter(val_dataset))
print(f'imgs.shape: {imgs.shape}, lbls.shape: {lbls.shape}')
# + [markdown] papermill={"duration": 0.019041, "end_time": "2021-05-05T14:17:27.152783", "exception": false, "start_time": "2021-05-05T14:17:27.133742", "status": "completed"} tags=[]
# # Model Config.
# + papermill={"duration": 0.026353, "end_time": "2021-05-05T14:17:27.198201", "exception": false, "start_time": "2021-05-05T14:17:27.171848", "status": "completed"} tags=[]
VOCAB_SIZE= 41
DECODER_DIM = 512
ATTENTION_UNITS = 256
# + papermill={"duration": 0.0456, "end_time": "2021-05-05T14:17:27.262727", "exception": false, "start_time": "2021-05-05T14:17:27.217127", "status": "completed"} tags=[]
class Encoderv1(tf.keras.Model):
"""Encoderv1"""
def __init__(self):
super(Encoderv1, self).__init__()
#output (8, 14, 1408)
self.fea_ext = efn.EfficientNetB2(include_top=False, weights='noisy-student')
global ENCODER_DIM
ENCODER_DIM = self.fea_ext.layers[-1].output_shape[-1]
self.reshape = tf.keras.layers.Reshape([-1, ENCODER_DIM], name='reshape_featuere_maps')
self.permuate = tf.keras.layers.Permute([2, 1], name='permutate_features_last')
def call(self, x, training):
x = self.fea_ext(x, training=training)
x = self.reshape(x, training=training)
x = self.permuate(x, training=training)
return x
class BahdanauAttention(tf.keras.layers.Layer):
"""BahdanauAttention"""
def __init__(self, units):
super(BahdanauAttention, self).__init__()
self.W1= tf.keras.layers.Dense(units, name='hidden_to_attention_units')
self.W2= tf.keras.layers.Dense(units, name='encoder_to_attention_units')
self.V= tf.keras.layers.Dense(1, name='score_to_alpha')
def call(self, h, encoder_res, training):
# dense hidden state to attention units size and expand dimension
hidden_with_time_axis = tf.expand_dims(h, 1)
hidden_with_time_axis = self.W1(hidden_with_time_axis, training=training)
# dense features to units size
encoder_res_dense = self.W2(encoder_res, training=training)
# add vectors
score = tf.math.tanh(hidden_with_time_axis + encoder_res_dense)
score = self.V(score, training=training)
# create alpha vector size (bs, layers)
attention_weights = tf.nn.softmax(score, axis=1)
# create attention weights (bs, layers)
context_vector = encoder_res * attention_weights # tf.expand_dims(attention_weights, axis=2)
context_vector = tf.reduce_sum(context_vector , axis=2)
return context_vector, attention_weights
class Decoder(tf.keras.Model):
def __init__(self, vocab_size, attention_units, encoder_dim, decoder_dim):
super(Decoder, self).__init__()
self.vocab_size = vocab_size
self.attention_units = attention_units
self.encoder_dim = encoder_dim
self.decoder_dim = decoder_dim
# LSTM hidden and carry state initialization
self.init_h = tf.keras.layers.Dense(units=decoder_dim, input_shape=[encoder_dim], name='encoder_res_to_hidden_init')
self.init_c = tf.keras.layers.Dense(units=decoder_dim, input_shape=[encoder_dim], name='encoder_res_to_inp_act_init')
# The LSTM cell
self.lstm_cell = tf.keras.layers.LSTMCell(decoder_dim, name='lstm_char_predictor')
# dropout before prediction
self.drop = tf.keras.layers.Dropout(0.3, name='prediction_dropout')
# fully connected prediction layer
self.fcn = tf.keras.layers.Dense(units=vocab_size, input_shape=[decoder_dim], activation='softmax', dtype=tf.float32, name='lstm_output_to_char_probs')
# character embedding layer
self.embedding = tf.keras.layers.Embedding(vocab_size, decoder_dim)
# used for attention
self.attention = BahdanauAttention(self.attention_units)
def call(self, char, h, c, enc_output, training):
# embed previous character
char = self.embedding(char, training=training)
char = tf.squeeze(char, axis=1)
#print('------', char.shape)
# get attention alpha and context vector
context, _ = self.attention(h, enc_output, training=training)
# concat context and char to create lstm input
lstm_input = tf.concat((context, char), axis=-1)
# LSTM call, get new h, c
_, (h_new, c_new) = self.lstm_cell(lstm_input, (h, c), training=training)
# compute predictions with dropout
output = self.drop(h_new, training=training)
output = self.fcn(output, training=training)
return output, h_new, c_new
def init_hidden_state(self, encoder_out, training):
mean_encoder_out = tf.math.reduce_mean(encoder_out, axis=1)
h = self.init_h(mean_encoder_out, training=training) # (batch_size, decoder_dim)
c = self.init_c(mean_encoder_out, training=training)
return h, c
# + papermill={"duration": 9.697653, "end_time": "2021-05-05T14:17:36.979524", "exception": false, "start_time": "2021-05-05T14:17:27.281871", "status": "completed"} tags=[]
encoder = Encoderv1()
encoder_res = encoder(imgs)
decoder = Decoder(VOCAB_SIZE, ATTENTION_UNITS, ENCODER_DIM, DECODER_DIM)
h, c = decoder.init_hidden_state(encoder_res, training=False)
preds, h, c = decoder(tf.random.uniform((BATCH_SIZE, 1)), h, c, encoder_res)
# + papermill={"duration": 1.914456, "end_time": "2021-05-05T14:17:38.917558", "exception": false, "start_time": "2021-05-05T14:17:37.003102", "status": "completed"} tags=[]
encoder.load_weights('../input/colabmodels-bms/BMS Model/encoder-imgnet-colab.h5')
decoder.load_weights('../input/colabmodels-bms/BMS Model/decoder-imgnet-colab.h5')
# + [markdown] papermill={"duration": 0.023038, "end_time": "2021-05-05T14:17:38.964303", "exception": false, "start_time": "2021-05-05T14:17:38.941265", "status": "completed"} tags=[]
# # Model Prediction
# + papermill={"duration": 0.035107, "end_time": "2021-05-05T14:17:39.022725", "exception": false, "start_time": "2021-05-05T14:17:38.987618", "status": "completed"} tags=[]
def get_pred(imgs):
enc_output = encoder(imgs, training=True)
h, c = decoder.init_hidden_state(enc_output, training=True)
dec_input = tf.zeros((imgs.shape[0], 1), tf.uint8)
predictions_seq = dec_input
for t in range(1, MAX_INCHI_LEN):
predictions, h, c = decoder(dec_input, h, c, enc_output, training=False)
dec_input= tf.expand_dims(tf.argmax(predictions, 1), 1)
dec_input= tf.cast(dec_input, tf.uint8)
predictions_seq= tf.concat([predictions_seq, dec_input], axis=1)
if t==1:
predictions_prob= predictions
else:
predictions_prob= tf.concat([predictions_prob, predictions], axis=1)
predictions_prob= tf.reshape(predictions_prob, (predictions_prob.shape[0], (MAX_INCHI_LEN-1), VOCAB_SIZE))
return predictions_seq, predictions_prob
# + papermill={"duration": 0.033449, "end_time": "2021-05-05T14:17:39.079407", "exception": false, "start_time": "2021-05-05T14:17:39.045958", "status": "completed"} tags=[]
def convert(inp):
string=''
for i in inp[1:]:
if i== 1:
break
string+= int_to_vocabulary[i]
return string
def process_pred(pred):
str_list=[]
for i in range(pred.shape[0]):
str_list.append(convert(pred[i].numpy()))
return str_list
# + papermill={"duration": 0.041434, "end_time": "2021-05-05T14:17:39.144380", "exception": false, "start_time": "2021-05-05T14:17:39.102946", "status": "completed"} tags=[]
def show(img, label, pred, bs_seq):
print('LABEL--',label)
print('\n')
print('PREDICTED--',pred)
print('\n')
print('BEAM SEARCH--',bs_seq)
plt.figure(figsize=(8, 8))
plt.imshow(-imgs[0])
plt.yticks([]);plt.xticks([])
plt.show()
# beam search
def beam_search_decoder(data, k):
sequences = [[list(), 0.0]]
# walk over each step in sequence
for row in data:
all_candidates = list()
# expand each current candidate
for i in range(len(sequences)):
seq, score = sequences[i]
for j in range(len(row)):
candidate = [seq + [j], score - log(row[j])]
all_candidates.append(candidate)
# order all candidates by score
ordered = sorted(all_candidates, key=lambda tup:tup[1])
# select k best
sequences = ordered[:k]
return sequences
def dense_to_sparse(dense):
ones = tf.ones(dense.shape)
indices = tf.where(ones)
values = tf.gather_nd(dense, indices)
sparse = tf.SparseTensor(indices, values, dense.shape)
return sparse
def get_levenshtein_distance(preds, lbls):
preds = tf.cast(preds, tf.int64)
preds = tf.where(tf.not_equal(preds, START_TOKEN) & tf.not_equal(preds, END_TOKEN) & tf.not_equal(preds, PAD_TOKEN), preds, y=0)
lbls = tf.cast(lbls, tf.int64)
lbls = tf.where(tf.not_equal(lbls, START_TOKEN) & tf.not_equal(lbls, END_TOKEN) & tf.not_equal(lbls, PAD_TOKEN), lbls, y=0)
preds_sparse = dense_to_sparse(preds)
lbls_sparse = dense_to_sparse(lbls)
batch_distance = tf.edit_distance(preds_sparse, lbls_sparse, normalize=False)
mean_distance = tf.math.reduce_mean(batch_distance)
return mean_distance
# + [markdown] papermill={"duration": 0.023551, "end_time": "2021-05-05T14:17:39.191561", "exception": false, "start_time": "2021-05-05T14:17:39.168010", "status": "completed"} tags=[]
# # Final Results
# + papermill={"duration": 28.642627, "end_time": "2021-05-05T14:18:07.857942", "exception": false, "start_time": "2021-05-05T14:17:39.215315", "status": "completed"} tags=[]
predictions_seq, predictions_prob= get_pred(imgs)
predictions_seq.shape, predictions_prob.shape
# + papermill={"duration": 227.887596, "end_time": "2021-05-05T14:21:55.769994", "exception": false, "start_time": "2021-05-05T14:18:07.882398", "status": "completed"} tags=[]
predictions_seq, predictions_prob= get_pred(imgs)
for i in range(BATCH_SIZE):
show(imgs[i], convert(lbls[i].numpy()),convert(predictions_seq[i].numpy()),
convert(beam_search_decoder(predictions_prob[i], 4)[1][0]))
print('LD for PREDICTED-', get_levenshtein_distance(predictions_seq[i][tf.newaxis, ],
lbls[i][tf.newaxis, ]).numpy())
print('LD for BEAM SEARCH-', get_levenshtein_distance(np.array([beam_search_decoder(predictions_prob[i], 4)[1][0]]),
lbls[i][tf.newaxis, 1:]).numpy())
print('***********************************************\n')
# + papermill={"duration": 0.079573, "end_time": "2021-05-05T14:21:55.930357", "exception": false, "start_time": "2021-05-05T14:21:55.850784", "status": "completed"} tags=[]
# + papermill={"duration": 0.081084, "end_time": "2021-05-05T14:21:56.092753", "exception": false, "start_time": "2021-05-05T14:21:56.011669", "status": "completed"} tags=[]
# + papermill={"duration": 0.078537, "end_time": "2021-05-05T14:21:56.250656", "exception": false, "start_time": "2021-05-05T14:21:56.172119", "status": "completed"} tags=[]
# + papermill={"duration": 0.086625, "end_time": "2021-05-05T14:21:56.416635", "exception": false, "start_time": "2021-05-05T14:21:56.330010", "status": "completed"} tags=[]
#(20, 199, 41)
#tf.reshape(predictions_prob, (predictions_prob.shape[0], (MAX_INCHI_LEN-1), VOCAB_SIZE))
# + papermill={"duration": 0.085725, "end_time": "2021-05-05T14:21:56.580981", "exception": false, "start_time": "2021-05-05T14:21:56.495256", "status": "completed"} tags=[]
# i= 18
# result = beam_search_decoder(predictions_prob[i], 6)
# # print result
# for seq in result:
# f = convert(seq[0])
# print('C'+ f)
# print(convert(predictions_seq.numpy()[i])[1:]==f)
# + papermill={"duration": 0.08588, "end_time": "2021-05-05T14:21:56.744886", "exception": false, "start_time": "2021-05-05T14:21:56.659006", "status": "completed"} tags=[]
# predictions_seq, predictions_prob= get_pred(imgs)
# for i in range(BATCH_SIZE):
# show(imgs[i], convert(lbls[i].numpy()),convert(predictions_seq[i].numpy()),
# convert(beam_search_decoder(predictions_prob[i], 2)[1][0]))
# print('***********************************************\n')
# + papermill={"duration": 0.079515, "end_time": "2021-05-05T14:21:56.903454", "exception": false, "start_time": "2021-05-05T14:21:56.823939", "status": "completed"} tags=[]
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3.8.5 64-bit
# metadata:
# interpreter:
# hash: 752579dbebe7f4dfe7c1aa72eac13e23fc88be2cc1ea7ab14e1f8d69b2d97d12
# name: python3
# ---
import numpy as np
import pennylane as qml
dev = qml.device("default.qubit", wires=4)
@qml.qnode(dev)
def circuit(params):
# |psi_0>: state preparation
qml.RY(np.pi / 4, wires=0)
qml.RY(np.pi / 3, wires=1)
qml.RY(np.pi / 7, wires=2)
# V0(theta0, theta1): Parametrized layer 0
qml.RZ(params[0], wires=0)
qml.RZ(params[1], wires=1)
# W1: non-parametrized gates
qml.CNOT(wires=[0, 1])
qml.CNOT(wires=[1, 2])
# V_1(theta2, theta3): Parametrized layer 1
qml.RY(params[2], wires=1)
qml.RX(params[3], wires=2)
# W2: non-parametrized gates
qml.CNOT(wires=[0, 1])
qml.CNOT(wires=[1, 2])
return qml.expval(qml.PauliY(0))
steps = 200
init_params = np.array([0.432, -0.123, 0.543, 0.233])
# +
qng_cost = []
opt = qml.QNGOptimizer(0.01)
theta = init_params
for _ in range(steps):
theta = opt.step(circuit, theta)
print(theta)
qng_cost.append(circuit(theta))
# +
from matplotlib import pyplot as plt
plt.style.use("seaborn")
plt.plot(qng_cost, "g", label="Quantum natural gradient descent")
plt.ylabel("Cost function value")
plt.xlabel("Optimization steps")
plt.legend()
plt.show()
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# 这里显示 PCA分析
import numpy as np
from matplotlib import pyplot as plt
from scipy import io as spio
# 可视化数据
# +
def plot_data_2d(X,marker):
plt.plot(X[:,0],X[:,1],marker)
return plt
def drawline(plt,p1,p2,line_type):
plt.plot(np.array([p1[0],p2[0]]),np.array([p1[1],p2[1]]),line_type)
def display_imageData(imgData):
sum = 0
'''
显示100个数（若是一个一个绘制将会非常慢，可以将要画的图片整理好，放到一个矩阵中，显示这个矩阵即可）
- 初始化一个二维数组
- 将每行的数据调整成图像的矩阵，放进二维数组
- 显示即可
'''
m,n = imgData.shape
width = np.int32(np.round(np.sqrt(n)))
height = np.int32(n/width)
rows_count = np.int32(np.floor(np.sqrt(m)))
cols_count = np.int32(np.ceil(m/rows_count))
pad = 1
display_array = -np.ones((pad+rows_count*(height+pad),pad+cols_count*(width+pad)))
for i in range(rows_count):
for j in range(cols_count):
max_val = np.max(np.abs(imgData[sum,:]))
display_array[pad+i*(height+pad):pad+i*(height+pad)+height,pad+j*(width+pad):pad+j*(width+pad)+width] = imgData[sum,:].reshape(height,width,order="F")/max_val # order=F指定以列优先，在matlab中是这样的，python中需要指定，默认以行
sum += 1
plt.imshow(display_array,cmap='gray') # 显示灰度图像
plt.axis('off')
plt.show()
# -
# 归一化以及映射
# +
def featureNormalize(X):
'''（每一个数据-当前列的均值）/当前列的标准差'''
n = X.shape[1]
mu = np.zeros((1,n))
sigma = np.zeros((1,n))
mu = np.mean(X,axis=0) # axis=0表示列
sigma = np.std(X,axis=0)
for i in range(n):
X[:,i] = (X[:,i]-mu[i])/sigma[i]
return X,mu,sigma
def projectData(X_norm,U,K):
Z = np.zeros((X_norm.shape[0],K))
U_reduce = U[:,0:K] # 取前K个
Z = np.dot(X_norm,U_reduce)
return Z
# -
# 数据恢复
def recoverData(Z,U,K):
X_rec = np.zeros((Z.shape[0],U.shape[0]))
U_recude = U[:,0:K]
X_rec = np.dot(Z,np.transpose(U_recude)) # 还原数据（近似）
return X_rec
# ### 2维数据降维1维
# +
data_2d = spio.loadmat("../data/6-PCA/data.mat")
X = data_2d['X']
m = X.shape[0]
plt = plot_data_2d(X,'bo') # 显示二维的数据
plt.show()
X_copy = X.copy()
X_norm,mu,sigma = featureNormalize(X_copy) # 归一化数据
#plot_data_2d(X_norm) # 显示归一化后的数据
#plt.show()
Sigma = np.dot(np.transpose(X_norm),X_norm)/m # 求Sigma
U,S,V = np.linalg.svd(Sigma) # 求Sigma的奇异值分解
plt = plot_data_2d(X,'bo') # 显示原本数据
drawline(plt, mu, mu+S[0]*(U[:,0]), 'r-') # 线，为投影的方向
plt.axis('square')
plt.show()
K = 1 # 定义降维多少维（本来是2维的，这里降维1维）
'''投影之后数据（降维之后）'''
Z = projectData(X_norm,U,K) # 投影
'''恢复数据'''
X_rec = recoverData(Z,U,K) # 恢复
'''作图-----原数据与恢复的数据'''
plt = plot_data_2d(X_norm,'bo')
plot_data_2d(X_rec,'ro')
for i in range(X_norm.shape[0]):
drawline(plt, X_norm[i,:], X_rec[i,:], '--k')
plt.axis('square')
plt.show()
# -
# ### 图像数据降维
# +
print (u'加载图像数据.....')
data_image = spio.loadmat('../data/6-PCA/data_faces.mat')
X = data_image['X']
display_imageData(X[0:100,:])
m = X.shape[0] # 数据条数
print(u'运行PCA....')
X_norm,mu,sigma = featureNormalize(X) # 归一化
Sigma = np.dot(np.transpose(X_norm),X_norm)/m # 求Sigma
U,S,V = np.linalg.svd(Sigma) # 奇异值分解
display_imageData(np.transpose(U[:,0:36])) # 显示U的数据
print(u'对face数据降维.....')
K = 100 # 降维100维(原先是32*32=1024维的)
Z = projectData(X_norm, U, K)
print(u'投影之后Z向量的大小：%d %d' %Z.shape)
print(u'显示降维之后的数据......')
X_rec = recoverData(Z, U, K) # 恢复数据
display_imageData(X_rec[0:100,:])
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab.research.google.com/github/GauravKakoti/Data-Science/blob/main/DiabetesPrediction(ArtificialNeuralNetwork).ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# + id="YUo46BM7ne1S"
#Description: This program detects if a person has diabetes or not
# + id="moiYMv1MolYz"
#Load Libraries
from keras.models import Sequential
from keras.layers import Dense
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
plt.style.use('fivethirtyeight')
# + id="KqrISDa8pnWY" outputId="8b635162-ba10-42a7-d0a3-78560fcec251" colab={"resources": {"http://localhost:8080/nbextensions/google.colab/files.js": {"data": "Ly8gQ29weXJpZ2h0IDIwMTcgR29vZ2xlIExMQwovLwovLyBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgIkxpY2Vuc2UiKTsKLy8geW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLgovLyBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQKLy8KLy8gICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAKLy8KLy8gVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZQovLyBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiAiQVMgSVMiIEJBU0lTLAovLyBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4KLy8gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZAovLyBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4KCi8qKgogKiBAZmlsZW92ZXJ2aWV3IEhlbHBlcnMgZm9yIGdvb2dsZS5jb2xhYiBQeXRob24gbW9kdWxlLgogKi8KKGZ1bmN0aW9uKHNjb3BlKSB7CmZ1bmN0aW9uIHNwYW4odGV4dCwgc3R5bGVBdHRyaWJ1dGVzID0ge30pIHsKICBjb25zdCBlbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc3BhbicpOwogIGVsZW1lbnQudGV4dENvbnRlbnQgPSB0ZXh0OwogIGZvciAoY29uc3Qga2V5IG9mIE9iamVjdC5rZXlzKHN0eWxlQXR0cmlidXRlcykpIHsKICAgIGVsZW1lbnQuc3R5bGVba2V5XSA9IHN0eWxlQXR0cmlidXRlc1trZXldOwogIH0KICByZXR1cm4gZWxlbWVudDsKfQoKLy8gTWF4IG51bWJlciBvZiBieXRlcyB3aGljaCB3aWxsIGJlIHVwbG9hZGVkIGF0IGEgdGltZS4KY29uc3QgTUFYX1BBWUxPQURfU0laRSA9IDEwMCAqIDEwMjQ7CgpmdW5jdGlvbiBfdXBsb2FkRmlsZXMoaW5wdXRJZCwgb3V0cHV0SWQpIHsKICBjb25zdCBzdGVwcyA9IHVwbG9hZEZpbGVzU3RlcChpbnB1dElkLCBvdXRwdXRJZCk7CiAgY29uc3Qgb3V0cHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG91dHB1dElkKTsKICAvLyBDYWNoZSBzdGVwcyBvbiB0aGUgb3V0cHV0RWxlbWVudCB0byBtYWtlIGl0IGF2YWlsYWJsZSBmb3IgdGhlIG5leHQgY2FsbAogIC8vIHRvIHVwbG9hZEZpbGVzQ29udGludWUgZnJvbSBQeXRob24uCiAgb3V0cHV0RWxlbWVudC5zdGVwcyA9IHN0ZXBzOwoKICByZXR1cm4gX3VwbG9hZEZpbGVzQ29udGludWUob3V0cHV0SWQpOwp9CgovLyBUaGlzIGlzIHJvdWdobHkgYW4gYXN5bmMgZ2VuZXJhdG9yIChub3Qgc3VwcG9ydGVkIGluIHRoZSBicm93c2VyIHlldCksCi8vIHdoZXJlIHRoZXJlIGFyZSBtdWx0aXBsZSBhc3luY2hyb25vdXMgc3RlcHMgYW5kIHRoZSBQeXRob24gc2lkZSBpcyBnb2luZwovLyB0byBwb2xsIGZvciBjb21wbGV0aW9uIG9mIGVhY2ggc3RlcC4KLy8gVGhpcyB1c2VzIGEgUHJvbWlzZSB0byBibG9jayB0aGUgcHl0aG9uIHNpZGUgb24gY29tcGxldGlvbiBvZiBlYWNoIHN0ZXAsCi8vIHRoZW4gcGFzc2VzIHRoZSByZXN1bHQgb2YgdGhlIHByZXZpb3VzIHN0ZXAgYXMgdGhlIGlucHV0IHRvIHRoZSBuZXh0IHN0ZXAuCmZ1bmN0aW9uIF91cGxvYWRGaWxlc0NvbnRpbnVlKG91dHB1dElkKSB7CiAgY29uc3Qgb3V0cHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG91dHB1dElkKTsKICBjb25zdCBzdGVwcyA9IG91dHB1dEVsZW1lbnQuc3RlcHM7CgogIGNvbnN0IG5leHQgPSBzdGVwcy5uZXh0KG91dHB1dEVsZW1lbnQubGFzdFByb21pc2VWYWx1ZSk7CiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZShuZXh0LnZhbHVlLnByb21pc2UpLnRoZW4oKHZhbHVlKSA9PiB7CiAgICAvLyBDYWNoZSB0aGUgbGFzdCBwcm9taXNlIHZhbHVlIHRvIG1ha2UgaXQgYXZhaWxhYmxlIHRvIHRoZSBuZXh0CiAgICAvLyBzdGVwIG9mIHRoZSBnZW5lcmF0b3IuCiAgICBvdXRwdXRFbGVtZW50Lmxhc3RQcm9taXNlVmFsdWUgPSB2YWx1ZTsKICAgIHJldHVybiBuZXh0LnZhbHVlLnJlc3BvbnNlOwogIH0pOwp9CgovKioKICogR2VuZXJhdG9yIGZ1bmN0aW9uIHdoaWNoIGlzIGNhbGxlZCBiZXR3ZWVuIGVhY2ggYXN5bmMgc3RlcCBvZiB0aGUgdXBsb2FkCiAqIHByb2Nlc3MuCiAqIEBwYXJhbSB7c3RyaW5nfSBpbnB1dElkIEVsZW1lbnQgSUQgb2YgdGhlIGlucHV0IGZpbGUgcGlja2VyIGVsZW1lbnQuCiAqIEBwYXJhbSB7c3RyaW5nfSBvdXRwdXRJZCBFbGVtZW50IElEIG9mIHRoZSBvdXRwdXQgZGlzcGxheS4KICogQHJldHVybiB7IUl0ZXJhYmxlPCFPYmplY3Q+fSBJdGVyYWJsZSBvZiBuZXh0IHN0ZXBzLgogKi8KZnVuY3Rpb24qIHVwbG9hZEZpbGVzU3RlcChpbnB1dElkLCBvdXRwdXRJZCkgewogIGNvbnN0IGlucHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGlucHV0SWQpOwogIGlucHV0RWxlbWVudC5kaXNhYmxlZCA9IGZhbHNlOwoKICBjb25zdCBvdXRwdXRFbGVtZW50ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQob3V0cHV0SWQpOwogIG91dHB1dEVsZW1lbnQuaW5uZXJIVE1MID0gJyc7CgogIGNvbnN0IHBpY2tlZFByb21pc2UgPSBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gewogICAgaW5wdXRFbGVtZW50LmFkZEV2ZW50TGlzdGVuZXIoJ2NoYW5nZScsIChlKSA9PiB7CiAgICAgIHJlc29sdmUoZS50YXJnZXQuZmlsZXMpOwogICAgfSk7CiAgfSk7CgogIGNvbnN0IGNhbmNlbCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2J1dHRvbicpOwogIGlucHV0RWxlbWVudC5wYXJlbnRFbGVtZW50LmFwcGVuZENoaWxkKGNhbmNlbCk7CiAgY2FuY2VsLnRleHRDb250ZW50ID0gJ0NhbmNlbCB1cGxvYWQnOwogIGNvbnN0IGNhbmNlbFByb21pc2UgPSBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gewogICAgY2FuY2VsLm9uY2xpY2sgPSAoKSA9PiB7CiAgICAgIHJlc29sdmUobnVsbCk7CiAgICB9OwogIH0pOwoKICAvLyBXYWl0IGZvciB0aGUgdXNlciB0byBwaWNrIHRoZSBmaWxlcy4KICBjb25zdCBmaWxlcyA9IHlpZWxkIHsKICAgIHByb21pc2U6IFByb21pc2UucmFjZShbcGlja2VkUHJvbWlzZSwgY2FuY2VsUHJvbWlzZV0pLAogICAgcmVzcG9uc2U6IHsKICAgICAgYWN0aW9uOiAnc3RhcnRpbmcnLAogICAgfQogIH07CgogIGNhbmNlbC5yZW1vdmUoKTsKCiAgLy8gRGlzYWJsZSB0aGUgaW5wdXQgZWxlbWVudCBzaW5jZSBmdXJ0aGVyIHBpY2tzIGFyZSBub3QgYWxsb3dlZC4KICBpbnB1dEVsZW1lbnQuZGlzYWJsZWQgPSB0cnVlOwoKICBpZiAoIWZpbGVzKSB7CiAgICByZXR1cm4gewogICAgICByZXNwb25zZTogewogICAgICAgIGFjdGlvbjogJ2NvbXBsZXRlJywKICAgICAgfQogICAgfTsKICB9CgogIGZvciAoY29uc3QgZmlsZSBvZiBmaWxlcykgewogICAgY29uc3QgbGkgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdsaScpOwogICAgbGkuYXBwZW5kKHNwYW4oZmlsZS5uYW1lLCB7Zm9udFdlaWdodDogJ2JvbGQnfSkpOwogICAgbGkuYXBwZW5kKHNwYW4oCiAgICAgICAgYCgke2ZpbGUudHlwZSB8fCAnbi9hJ30pIC0gJHtmaWxlLnNpemV9IGJ5dGVzLCBgICsKICAgICAgICBgbGFzdCBtb2RpZmllZDogJHsKICAgICAgICAgICAgZmlsZS5sYXN0TW9kaWZpZWREYXRlID8gZmlsZS5sYXN0TW9kaWZpZWREYXRlLnRvTG9jYWxlRGF0ZVN0cmluZygpIDoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ24vYSd9IC0gYCkpOwogICAgY29uc3QgcGVyY2VudCA9IHNwYW4oJzAlIGRvbmUnKTsKICAgIGxpLmFwcGVuZENoaWxkKHBlcmNlbnQpOwoKICAgIG91dHB1dEVsZW1lbnQuYXBwZW5kQ2hpbGQobGkpOwoKICAgIGNvbnN0IGZpbGVEYXRhUHJvbWlzZSA9IG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7CiAgICAgIGNvbnN0IHJlYWRlciA9IG5ldyBGaWxlUmVhZGVyKCk7CiAgICAgIHJlYWRlci5vbmxvYWQgPSAoZSkgPT4gewogICAgICAgIHJlc29sdmUoZS50YXJnZXQucmVzdWx0KTsKICAgICAgfTsKICAgICAgcmVhZGVyLnJlYWRBc0FycmF5QnVmZmVyKGZpbGUpOwogICAgfSk7CiAgICAvLyBXYWl0IGZvciB0aGUgZGF0YSB0byBiZSByZWFkeS4KICAgIGxldCBmaWxlRGF0YSA9IHlpZWxkIHsKICAgICAgcHJvbWlzZTogZmlsZURhdGFQcm9taXNlLAogICAgICByZXNwb25zZTogewogICAgICAgIGFjdGlvbjogJ2NvbnRpbnVlJywKICAgICAgfQogICAgfTsKCiAgICAvLyBVc2UgYSBjaHVua2VkIHNlbmRpbmcgdG8gYXZvaWQgbWVzc2FnZSBzaXplIGxpbWl0cy4gU2VlIGIvNjIxMTU2NjAuCiAgICBsZXQgcG9zaXRpb24gPSAwOwogICAgd2hpbGUgKHBvc2l0aW9uIDwgZmlsZURhdGEuYnl0ZUxlbmd0aCkgewogICAgICBjb25zdCBsZW5ndGggPSBNYXRoLm1pbihmaWxlRGF0YS5ieXRlTGVuZ3RoIC0gcG9zaXRpb24sIE1BWF9QQVlMT0FEX1NJWkUpOwogICAgICBjb25zdCBjaHVuayA9IG5ldyBVaW50OEFycmF5KGZpbGVEYXRhLCBwb3NpdGlvbiwgbGVuZ3RoKTsKICAgICAgcG9zaXRpb24gKz0gbGVuZ3RoOwoKICAgICAgY29uc3QgYmFzZTY0ID0gYnRvYShTdHJpbmcuZnJvbUNoYXJDb2RlLmFwcGx5KG51bGwsIGNodW5rKSk7CiAgICAgIHlpZWxkIHsKICAgICAgICByZXNwb25zZTogewogICAgICAgICAgYWN0aW9uOiAnYXBwZW5kJywKICAgICAgICAgIGZpbGU6IGZpbGUubmFtZSwKICAgICAgICAgIGRhdGE6IGJhc2U2NCwKICAgICAgICB9LAogICAgICB9OwogICAgICBwZXJjZW50LnRleHRDb250ZW50ID0KICAgICAgICAgIGAke01hdGgucm91bmQoKHBvc2l0aW9uIC8gZmlsZURhdGEuYnl0ZUxlbmd0aCkgKiAxMDApfSUgZG9uZWA7CiAgICB9CiAgfQoKICAvLyBBbGwgZG9uZS4KICB5aWVsZCB7CiAgICByZXNwb25zZTogewogICAgICBhY3Rpb246ICdjb21wbGV0ZScsCiAgICB9CiAgfTsKfQoKc2NvcGUuZ29vZ2xlID0gc2NvcGUuZ29vZ2xlIHx8IHt9OwpzY29wZS5nb29nbGUuY29sYWIgPSBzY29wZS5nb29nbGUuY29sYWIgfHwge307CnNjb3BlLmdvb2dsZS5jb2xhYi5fZmlsZXMgPSB7CiAgX3VwbG9hZEZpbGVzLAogIF91cGxvYWRGaWxlc0NvbnRpbnVlLAp9Owp9KShzZWxmKTsK", "ok": true, "headers": [["content-type", "application/javascript"]], "status": 200, "status_text": ""}}, "base_uri": "https://localhost:8080/", "height": 72}
#Load the Data
from google.colab import files
uploaded = files.upload()
# + id="x3l6kSZvqHcx" outputId="ca639ebb-5ba9-48e3-ff94-7fbf3b409049" colab={"base_uri": "https://localhost:8080/", "height": 266}
#Store the data set
df = pd.read_csv('datasets_228_482_diabetes.csv')
#Print the first 7 rows odf data
df.head(7)
# + id="hJ-9lUWfq1aj" outputId="13b2e4e4-9a05-470c-919b-89862c249296" colab={"base_uri": "https://localhost:8080/", "height": 34}
#Show the shape (No. of rows and columns)
df.shape
# + id="-4ikexyOq__T"
#Check for duplicacies and remove them
df.drop_duplicates(inplace= True)
# + id="jp5mO31rrQoK" outputId="8e3a45ee-56ea-442e-d06c-f656835e7c64" colab={"base_uri": "https://localhost:8080/", "height": 34}
#Show the shape (No. of rows and columns)
df.shape
# + id="RZ6J07w0rWJp" outputId="ae5d8ca7-556c-4b9e-8e8a-34813106d551" colab={"base_uri": "https://localhost:8080/", "height": 187}
#show the no. of missing data for each column
df.isnull().sum()
# + id="MB2JCI8XriSk" outputId="d546ae2a-4169-42ae-ac43-344819990288" colab={"base_uri": "https://localhost:8080/", "height": 136}
#Convert the data into array
dataset = df.values
dataset
# + id="fEq20VE7rugS"
#Get all of the rows from the first eight columns of the dataset
X = dataset[:, 0:8]
Y = dataset[:, 8]
# + id="dYt9EsfwsIPJ" outputId="9b8a93b5-4ebb-48e3-e380-465567c485f6" colab={"base_uri": "https://localhost:8080/", "height": 238}
#Process the data
from sklearn import preprocessing
min_max_scaler = preprocessing.MinMaxScaler()
X_scale = min_max_scaler.fit_transform(X)
X_scale
# + id="FVuZRoE8s-8s"
#Split the data into 80% training and 20% testing
X_train, X_test, Y_train, Y_test = train_test_split(X_scale,Y, test_size =0.2, random_state = 4)
# + id="ngg-4KbvthtO"
#Build the Model
model = Sequential([
Dense(12, activation='relu', input_shape=(8,)),
Dense(15, activation='relu'),
Dense(1, activation='sigmoid')
])
# + id="DVdMUhXQuNQk"
#Compile the Model
model.compile(
optimizer = 'sgd',
loss = 'binary_crossentropy',
metrics = ['accuracy']
)
# + id="1INtm3tzu288" outputId="bf1002bb-c988-4e5d-dcc3-6706e69ba07f" colab={"base_uri": "https://localhost:8080/", "height": 1000}
#Train the Model
hist = model.fit(X_train, Y_train, batch_size = 57, epochs=1000, validation_split=0.2)
# + id="bStZgFfZvxzq" outputId="a8f6b744-2b76-47d0-ea62-1bad607542e9" colab={"base_uri": "https://localhost:8080/", "height": 325}
#Visualize the training loss and validation loss to see if the model is overfitting
plt.plot(hist.history['loss'])
plt.plot(hist.history['val_loss'])
plt.title('Model loss')
plt.ylabel('loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Val'], loc = 'upper right')
plt.show()
# + id="u1VgO0yow2hM" outputId="cd3fae79-f2a6-44b7-987c-b4230a96ba36" colab={"base_uri": "https://localhost:8080/", "height": 325}
#Visualize the training accuracy and validation accuracy to see if the model is overfitting
plt.plot(hist.history['accuracy'])
plt.plot(hist.history['val_accuracy'])
plt.title('Model Accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Val'], loc = 'lower right')
plt.show()
# + id="jAyZEYT-xvVa" outputId="b33a0d4f-896b-4953-c0d6-cc3c98a9628f" colab={"base_uri": "https://localhost:8080/", "height": 173}
#Make a prediction & print the actual values
prediction = model.predict(X_test)
prediction = [1 if Y>= 0.5 else 0 for Y in prediction]
print(prediction)
print(Y_test)
# + id="KtKf7nrWyyBC" outputId="2a50abac-08e9-4958-a4cb-affe5987d556" colab={"base_uri": "https://localhost:8080/", "height": 255}
#Evaluate the model on the training dataset
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
pred = model.predict(X_train)
pred = [1 if Y>= 0.5 else 0 for Y in pred]
print(classification_report(Y_train, pred))
print('Confusion Matrix: \n', confusion_matrix(Y_train, pred))
print()
print('Accuracy: ', accuracy_score(Y_train, pred))
# + id="Cakm4ZrV0gKw" outputId="67f7fc3f-1e84-4d19-a865-2d6cc639cdd8" colab={"base_uri": "https://localhost:8080/", "height": 255}
#Evaluate the model on the test dataset
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
pred = model.predict(X_test)
pred = [1 if Y>= 0.5 else 0 for Y in pred]
print(classification_report(Y_test, pred))
print('Confusion Matrix: \n', confusion_matrix(Y_test, pred))
print()
print('Accuracy: ', accuracy_score(Y_test, pred))
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + id="XDzxFH5bfKcT" colab_type="code" outputId="94d2f884-bc4f-4ef0-b3a5-e4b88dba2b1e" colab={"base_uri": "https://localhost:8080/", "height": 35}
# ls
# + id="yszywjBMfLSq" colab_type="code" outputId="0fa7c504-ec0a-4c0f-8219-4f428cc1e590" colab={"base_uri": "https://localhost:8080/", "height": 127}
from google.colab import drive
drive.mount('/content/drive/')
# + id="l1hA9b-EfQl5" colab_type="code" outputId="854a3c1c-4989-4067-a774-7c70e92bda21" colab={"base_uri": "https://localhost:8080/", "height": 35}
# ls
# + id="ujIRUND-fcdh" colab_type="code" outputId="58e71827-7137-4e3e-ed5c-b96160afb5e4" colab={"base_uri": "https://localhost:8080/", "height": 35}
# cd drive/My\ Drive
# + id="zxuZscIafjXT" colab_type="code" outputId="9dca6d8d-5ee3-45f2-f0fa-bb0d4c11340e" colab={"base_uri": "https://localhost:8080/", "height": 107}
# ls
# + id="ZPhpazcWfkTf" colab_type="code" outputId="d439ec78-1b68-490e-c8e2-2c7080171056" colab={"base_uri": "https://localhost:8080/", "height": 35}
# cd CITREP_Data+Code/
# + id="TGgaIPcxfniu" colab_type="code" outputId="f42f5b8c-2bba-4745-ebfc-ef1457bab8f9" colab={"base_uri": "https://localhost:8080/", "height": 451}
# ls
# + id="ljGO6NmIfoKT" colab_type="code" outputId="551b3c6e-6bf8-4452-8bfd-3b88540666fe" colab={"base_uri": "https://localhost:8080/", "height": 35}
import tensorflow as tf
print(tf.__version__)
# + id="5qDHf-yPgBt-" colab_type="code" outputId="e61ce765-a4fb-4b16-85df-b851d8b4c14a" colab={"base_uri": "https://localhost:8080/", "height": 35}
a=1
b=2
c= a+b
print(a,b,c)
# + id="lxe-MBdchMpD" colab_type="code" outputId="6778dbea-a399-49e7-dace-b2b5d18bb8dc" colab={"base_uri": "https://localhost:8080/", "height": 71}
#meanwhile in tensorflow:
a = tf.constant(1)
b = tf.constant(2)
c = tf.add(a,b)
print(a)
print(b)
print(c)
# + id="_JIPprAnhXih" colab_type="code" colab={}
#Within tensorflow you have to run a session, if not you won't be able to run
#run session:
#just run this once
sess = tf.Session()
# + id="Fof3PDX_h5UA" colab_type="code" outputId="4732a7c1-2905-4346-ba6c-1be9d964eb65" colab={"base_uri": "https://localhost:8080/", "height": 71}
print(sess.run(a))
print(sess.run(b))
print(sess.run(c))
#within tensorflow, you won't be able to run different data types
# + id="j5ScjMXkh-i2" colab_type="code" outputId="3e562e6c-b1c7-4399-dcd7-d991dbdd0243" colab={"base_uri": "https://localhost:8080/", "height": 35}
#or
with tf.Session() as sess:
print(sess.run(a))
# + id="X-b-GC5Xi08r" colab_type="code" colab={}
sess = tf.Session()
a = tf.constant(1, dtype=tf.float32)
b = tf.constant(2.5)
c = tf.add(a,b)
d = tf.floordiv(a,b)
# + id="BCQjJGnUi_6d" colab_type="code" outputId="8f088cf8-35c3-46ae-8f35-fd066b262d7d" colab={"base_uri": "https://localhost:8080/", "height": 89}
print(sess.run(a))
print(sess.run(b))
print(sess.run(c))
print(sess.run(d))
# + id="h4p14RnsjjgE" colab_type="code" outputId="aeaadbe8-6f8a-4895-c47f-89b142f6796c" colab={"base_uri": "https://localhost:8080/", "height": 35}
#exercise
sess = tf.Session()
a = tf.constant(3, dtype = tf.float32)
b = tf.constant(4.1, dtype = tf.float32)
c = tf.constant(5, dtype = tf.float32)
d = tf.add(tf.multiply(a,b), c)
print(sess.run(d))
# + id="AnFA6gIbluBj" colab_type="code" outputId="112f1435-0e66-435d-f76a-a7099ad83e87" colab={"base_uri": "https://localhost:8080/", "height": 71}
#building a matrix:
#make sure to put two brackets
a = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(sess.run(a))
# + id="gbeipRNBl5l9" colab_type="code" outputId="a2bf9734-554e-4def-81e8-98efdab50fcf" colab={"base_uri": "https://localhost:8080/", "height": 35}
print(sess.run(tf.shape(a)))
# + id="ky1UWT4gmQF0" colab_type="code" outputId="8a1ca24c-ec98-412c-cf0e-06377fa4f5c3" colab={"base_uri": "https://localhost:8080/", "height": 53}
#to slice the data
# [0, 1] is index of [row, column]
#[2, 2] is the dimensions that you want the data to be cut
print(sess.run(tf.slice(a, [0, 1], [2, 2])))
# + id="xjbsZKq_rSAk" colab_type="code" colab={}
#matrix operators:
a = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
# Transpose - tf.transpose(a)
# Inverse - tf.matrix_inverse(a)
# Dot Product – tf.tensordot(a,b, axes=0)
# Matrix Multiplication - tf.matmul(a, b)
# Solve A.x = b - tf.matrix_solve(A,b)
# + id="TZQ2iPRvoZnB" colab_type="code" colab={}
#exercise matrix
x = [[1.1,1.2]] w = [[1,2],[3,4]] b = [[2.3,2.5]] y = x*w+b
# + id="r6uK9LTyoKfM" colab_type="code" outputId="eb1b1fe7-4844-4189-b7cb-8302f9a038d9" colab={"base_uri": "https://localhost:8080/", "height": 53}
#finding the index of the minimum and maximum
a = tf.constant([13,2,20,10,1,2,3])
print(sess.run(tf.argmin(a)))
print(sess.run(tf.argmax(a)))
# + id="-Xj640nmuCzD" colab_type="code" outputId="1c579d12-958c-4c29-a64a-ac691fed4962" colab={"base_uri": "https://localhost:8080/", "height": 107}
a = tf.constant( [[1,1,1], [2,2,2]] )
print("a:",sess.run(a))
print("Reduced Sum:",sess.run(tf.reduce_sum(a)))
print(sess.run(tf.reduce_sum(a, 0))) # Column sum
print(sess.run(tf.reduce_sum(a, 1))) # Row sum
# + id="jGoDWZK1uIGO" colab_type="code" outputId="3e791b9c-0859-40f2-c929-4471a9396160" colab={"base_uri": "https://localhost:8080/", "height": 53}
#from -10 to 10, create a row that has 10 values equally spaced
#generates 10 numbers equally spaced between -10 to 10
a = tf.linspace(-10., 10., 10)
print(sess.run(a))
# + id="gjUdOQoUuWJY" colab_type="code" outputId="3a562c3f-a3ec-4a16-8270-3a1bdf0e04b6" colab={"base_uri": "https://localhost:8080/", "height": 197}
a = tf.linspace(-10., 10., 50)
print(sess.run(a))
# + id="sQsQWv3ouqtL" colab_type="code" colab={}
#during initialization of neural networks
#use a placeholder
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
sum = tf.add(a,b)
print(sess.run(sum,feed_dict={a:3,b:4}))
# + id="AmpoBNwwvJEC" colab_type="code" colab={}
#Variable
a = tf.Variable([.3], tf.float32)
b = tf.Variable([-.1], tf.float32)
x = tf.placeholder(tf.float32)
y = a * x + b
# + id="MV09REMIy90l" colab_type="code" colab={}
#---------------------------------------------------------------------------------------
# + id="vM2mcZw9y_eK" colab_type="code" colab={}
#-----------------------------------DATASETS & Data Split--------------------------------
# + id="pXuVZUngzFN-" colab_type="code" colab={}
# softmax activation function explanation:
# if the number of neurons in the output layer is more than 2, then you must use the softmax activation function
# each of the neurons represents one of the class
# # let us say we have 4 different images: dog, cat, bird and car
# that is why we put 4 neurons in our output layer
#one of the classes, let us say dog neuron replaces one of the neurons in the output layer
# softmax converts the raw number into a probability
# the way it does it is by taking each of the raw values given from the output and dividing it by the sum of total raw values given out by each of the neurons in the output layer
# and based on the probability, it states what image it is whether it is a dog image, or a car image for example
# if you don't use softmax, then you'll have to go through if loop to derive the result
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# +
# %matplotlib notebook
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn
import seaborn as sns
import csv
from sklearn import tree
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
import itertools
from sklearn import preprocessing
from sklearn.ensemble import RandomForestClassifier
import random
random.seed(0)
from sklearn.metrics import precision_recall_curve
from sklearn.metrics import average_precision_score
from sklearn.metrics import f1_score
plt.ioff()
pd.set_option('display.max_columns', None)
# -
# ## Go To https://www.kaggle.com/dalpozz/creditcardfraud
data_frame = pd.read_csv('data/creditcard.csv')
data_frame.head()
data_frame.describe()
X = np.array(data_frame.drop('Class', axis=1))
print(X.shape)
Y = np.array(data_frame['Class'])
frauds = np.where(Y==1)[0]
non_frauds = np.where(Y==0)[0]
n_frauds = len(frauds)
print("There are {} frauds among {} transations".format(n_frauds, len(Y)))
# +
### How to deal with such an imbalance?
# +
# balance dataset
print(X.shape)
undersampled_non_frauds = random.sample(non_frauds, n_frauds)
indexes_to_keep = list(frauds) + list(undersampled_non_frauds)
indexes_to_remove = [i for i in range(X.shape[0]) if i not in indexes_to_keep]
X_keep = np.take(X, indexes_to_keep, axis=0)
Y_keep = np.take(Y, indexes_to_keep, axis=0)
# +
X_train, X_test, Y_train, Y_test = train_test_split(X_keep, Y_keep, test_size=1/4., random_state=0)
X_test = np.concatenate((X_test, np.take(X, indexes_to_remove, axis=0)))
Y_test = np.concatenate((Y_test, np.take(Y, indexes_to_remove, axis=0)))
# +
model = RandomForestClassifier(max_depth=4, n_estimators=50)
model.fit(X_train, Y_train)
Y_train_pred = model.predict(X_train)
Y_test_pred = model.predict(X_test)
Y_train_score = np.max(model.predict_proba(X_train), axis=1)
Y_test_score = np.max(model.predict_proba(X_test), axis=1)
train_mse = sklearn.metrics.mean_squared_error(Y_train, Y_train_pred)
test_mse = sklearn.metrics.mean_squared_error(Y_test, Y_test_pred)
print("Train MSE {}".format(train_mse))
print("Test MSE {}".format(test_mse))
train_accuracy = sklearn.metrics.accuracy_score(Y_train, Y_train_pred)
test_accuracy = sklearn.metrics.accuracy_score(Y_test, Y_test_pred)
print("Train Accuracy {}%".format(train_accuracy*100.0))
print("Test Accuracy {}%".format(test_accuracy*100))
# -
print("Test Precision {}".format(sklearn.metrics.precision_score(Y_test, Y_test_pred)))
print("Test Recall {}".format(sklearn.metrics.recall_score(Y_test, Y_test_pred)))
print("Test f1 Score {}".format(f1_score(Y_test, Y_test_pred)))
cf_matrix = confusion_matrix(Y_test, Y_test_pred)
cf_matrix
# +
# plot AUC, precision, recall
print(Y_test.shape)
precision, recall, _ = precision_recall_curve(Y_test, Y_test_score)
average_precision = average_precision_score(Y_test, Y_test_score)
plt.step(recall, precision, color='b', alpha=0.2,
where='post')
plt.fill_between(recall, precision, step='post', alpha=0.2,
color='b')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.title('Precision-Recall curve: AUC={0:0.2f}'.format(
average_precision))
plt.show()
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
from bs4 import BeautifulSoup as BS
from selenium import webdriver
from functools import reduce
import pandas as pd
import time
import xport
import pandas as pd
import numpy as np
def render_page(url):
driver = webdriver.Chrome('/Users/cp/Downloads/chromedriver')
driver.get(url)
time.sleep(3)
r = driver.page_source
driver.quit()
return r
def scraper2(page, dates):
output = pd.DataFrame()
for d in dates:
url = str(str(page) + str(d))
r = render_page(url)
soup = BS(r, "html.parser")
container = soup.find('lib-city-history-observation')
check = container.find('tbody')
data = []
for c in check.find_all('tr', class_='ng-star-inserted'):
for i in c.find_all('td', class_='ng-star-inserted'):
trial = i.text
trial = trial.strip(' ')
data.append(trial)
if len(data)%2 == 0:
hour = pd.DataFrame(data[0::10], columns = ['hour'])
temp = pd.DataFrame(data[1::10], columns = ['temp'])
dew = pd.DataFrame(data[2::10], columns = ['dew'])
humidity = pd.DataFrame(data[3::10], columns = ['humidity'])
wind_speed = pd.DataFrame(data[5::10], columns = ['wind_speed'])
pressure = pd.DataFrame(data[7::10], columns = ['pressure'])
precip = pd.DataFrame(data[8::10], columns = ['precip'])
cloud = pd.DataFrame(data[9::10], columns = ['cloud'])
dfs = [hour, temp,dew,humidity, wind_speed, pressure, precip, cloud]
df_final = reduce(lambda left, right: pd.merge(left, right, left_index=True, right_index=True), dfs)
df_final['Date'] = str(d) + "-" + df_final.iloc[:, :1].astype(str)
output = output.append(df_final)
print('Scraper done!')
output = output[['hour', 'temp', 'dew', 'humidity', 'wind_speed', 'pressure',
'precip', 'cloud']]
return output
def jan_dates():
lst = []
for i in range(1, 32):
i = str(i)
lst.append(str("2021-1-"+i))
return lst
january = jan_dates()
def feb_dates():
lst = []
for i in range(1, 30):
i = str(i)
lst.append(str("2020-2-"+i))
return lst
feb = feb_dates()
def march_dates():
lst = []
for i in range(1, 32):
i = str(i)
lst.append(str("2020-3-"+i))
return lst
mar = march_dates()
def april_dates():
lst = []
for i in range(1, 31):
i = str(i)
lst.append(str("2020-4-"+i))
return lst
april = april_dates()
def may_dates():
lst = []
for i in range(1, 32):
i = str(i)
lst.append(str("2020-5-"+i))
return lst
may = may_dates()
def june_dates():
lst = []
for i in range(1, 31):
i = str(i)
lst.append(str("2020-6-"+i))
return lst
june = june_dates()
def july_dates():
lst = []
for i in range(1, 32):
i = str(i)
lst.append(str("2020-7-"+i))
return lst
july = july_dates()
def august_dates():
lst = []
for i in range(1, 32):
i = str(i)
lst.append(str("2020-8-"+i))
return lst
august = august_dates()
def october_dates():
lst = []
for i in range(1, 32):
i = str(i)
lst.append(str("2020-10-"+i))
return lst
october = october_dates()
def november_dates():
lst = []
for i in range(1, 31):
i = str(i)
lst.append(str("2020-11-"+i))
return lst
november_to7 = november_dates()
def december_dates():
lst = []
for i in range(1, 32):
i = str(i)
lst.append(str("2020-12-"+i))
return lst
december = december_dates()
# +
def make_year_dates(yr= 2020):
if yr%4 ==0:
feb_days = 30
else:
feb_days = 29
yr = str(yr)
january = []
for i in range(1, 32):
i = str(i)
january.append(f"{yr}-1-{i}")
feb = []
for i in range(1, feb_days):
i = str(i)
feb.append(f"{yr}-2-{i}")
march = []
for i in range(1, 32):
i = str(i)
march.append(f"{yr}-3-{i}")
april = []
for i in range(1, 31):
i = str(i)
april.append(f"{yr}-4-{i}")
may = []
for i in range(1, 32):
i = str(i)
may.append(f"{yr}-5-{i}")
june = []
for i in range(1, 31):
i = str(i)
june.append(f"{yr}-6-{i}")
july = []
for i in range(1, 32):
i = str(i)
july.append(f"{yr}-7-{i}")
august = []
for i in range(1, 32):
i = str(i)
august.append(f"{yr}-8-{i}")
september = []
for i in range(1, 31):
i = str(i)
september.append(f"{yr}-9-{i}")
october = []
for i in range(1, 32):
i = str(i)
october.append(f"{yr}-10-{i}")
november = []
for i in range(1, 31):
i = str(i)
november.append(f"{yr}-11-{i}")
december = []
for i in range(1, 32):
i = str(i)
december.append(f"{yr}-12-{i}")
yr_total = january+feb+ march+ april+ may+ june + july + august+ september+ october+ november+ december
return yr_total
# ?january, feb, march, april, may, june, july, august, september, october, november, december
# -
make_year_dates(yr= 2019)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# <hr style="border:0.2px solid black"> </hr>
#
# <figure>
# <IMG SRC="ntnu_logo.png" WIDTH=250 ALIGN="right">
# </figure>
#
# **<ins>Course:</ins>** TVM4174 - Hydroinformatics for Smart Water Systems
#
# # <ins>Project:</ins> WNTR Educational Notebook
#
# *Developed by Christian Skagsoset and Joakim Skjelde*
#
# <hr style="border:0.2px solid black"> </hr>
#
# # Introduction
#
# This Notebook is developed as a project assignment in the course `TVM4174: Hydroinformatics for smart water systems` at NTNU.
# The Notebook is meant to be used to get familiar and practise your skills in using the WNTR-package in Python.
# The tasks in this Notebook is created based on what the students are using in exercises in the following courses at NTNU:
# * `TVM4130: Urban Water Systems`
# * `TVM4174: Hydroinformatics for Smart Water Systems`
#
#
# # Prerequisites
# The use of this Notebook requires a relatively good knowledge in Python programming, with packages as Pandas, Matplotlib and Numpy, since all these packages will be used in this Notebook.
#
# If you are a bit rusty in the usage of Python in general, or some of the packages, we recommend looking through the Notebooks of Professor Mark Bakker from TU Delft. These Notebooks contains short lecture videos, theory and exercises with different degree of difficulty.
# It's recommended to do the following Notebooks from Professor Bakker before trying out this `WNTR-Notebook`:
# * Notebook 1 - Basics and plotting
# * Notebook 2 - Arrays
# * Notebook 3 - For loops and If/Else statements
# * Notebook 4 - Functions
# * Notebook 8 - Pandas and Time Series
#
# The following hyperlink leads you to the webpage of [Professor Bakker's Notebooks](https://mbakker7.github.io/exploratory_computing_with_python/)
#
#
# # Structure of Notebook
# The Notebook switches between introduction of how to operate the `WNTR-package` and the task for you to put theory into practice. The important info to solve each task is given with examples in advance, which should make you able to solve the different tasks. In some of the tasks you will need the knowledge of the different `Python-packages` mentioned above, which will be a bit more challenging.
# ## What is EPANET and WNTR?
# #### EPANET
# EPANET was developed by Lewis Rossman, for the United States Environmental Protection Agency (US EPA), in the early 90s, and is a software used to model water distribution systems. The program is public domain and has an open-source code, making it popular in use. The program can perform hydraulic modelling, water quality modelling and resilience modelling, making it robust and useful in many cases for engineers. For the case of this notebook, the focus is hydraulic modelling. For further info about the program, the following webpages are recommended:
# * [US EPA](https://www.epa.gov/water-research/epanet)
# * [EPANET Documentation](https://epanet22.readthedocs.io/en/latest/index.html)
# * [EPANET.no](https://epanet.no/)
#
# #### WNTR
# WNTR(Water Network Tool for Resilience) is a Python package used to simulate and analyze the resilience of water network systems. The package is based on EPANET, and can in principal do everything EPANET can, and a lot more. The package is very efficient together with other Python packages to perform calculations, analyzes and visualizations of the water network. In this Notebook, you will experience a whole range of the performances and capabilities of the package, but there is alot more to discover for those of interest. The following links is very useful and educational to use when exploring the package.
# * [WNTR Documentation](https://wntr.readthedocs.io/en/latest/overview.html)
# * [WNTR GitHub](https://github.com/USEPA/WNTR)
#
#
# # The EPANET input-file
#
# To run a model in EPANET, or WNTR, we need an input-file, called INP-file. This file contains all attributes to run the model in the software, with nodes, links, patterns and hydraulic options to mention some.
#
# It is also possible to make your own model in both EPANET and WNTR, but this will be shown later in the Notebook.
# ## Installing and importing the WNTR-package
# To use the WNTR-package, we need to install it and import it. In Jupyter Notebooks you normally have to install the package for every time you use a different Notebook. If you are using an IDE for your programming, it is normally enough to install the file once, and then being able to use it further.
# The good thing is that you usually get an error message if you try to import the package without it being installed.
# Installing the wntr-package
# The normal installing method in Python is using the pip-install function
# !pip install wntr
# +
# Importing the package
import wntr
# We also need to use other python packages, so we import the most relevant ones.
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# %matplotlib inline
plt.rcParams['figure.dpi'] = 150
# -
# ## Importing the INP-file
#
# To start working on a nettwork you have to import the network from a EPA-Net input file and store it as a variable. This variable is normaly stored as wn, short for water network. This is the variable that you normally work, you can also use this variable to overwrite or create a new input file whenever you want. In the examples of the Notebook, we will use the Net1-network, for the exercise you will use the Net3-network.
#
# More information about importing the system: [Getting Started](https://wntr.readthedocs.io/en/latest/getting_started.html)
#
#
# Before doing any work to on a network, it would be handy to check if you have imported the correct network and to see what the system consists of. To plot the newly imported network, you can use the function: `wntr.graphics.plot_network`
#
# Check out [Network](https://wntr.readthedocs.io/en/latest/graphics.html#networks) for more information about `wntr.graphics.plot_network`
#
# To see what the system consists of you can use: `wn.describe`, [Describe](https://wntr.readthedocs.io/en/latest/apidoc/wntr.network.model.html?highlight=describe#wntr.network.model.WaterNetworkModel.describe)
# +
# Assigning the INP-file to a variable
input_file = 'Net1_project.inp'
# Using the above variable in the wntr command to create a network model. Usually we give the network the name wn(water network)
wn = wntr.network.WaterNetworkModel(input_file)
# To check if you actually have a model now, you can plot the network.
wntr.graphics.plot_network(wn)
# -
# ## Check and change units
# EPANET can operate with both US-customary and SI-based units. We would like our model to run with SI-units, so we need to check which units the network is set to now, to see if we need to change anything.
# Checking the current units of the input file
wn.options.hydraulic.inpfile_units
# The units is set to GPM (gallons per minute), but we want it in LPS (litre per second). To change this, we could use wntr to write a new input file in the unit type that we want. Using the function `wn.write_inpfile` we can set the units to LPS and the whole input file will change according to it.
#
# [Units](https://wntr.readthedocs.io/en/latest/units.html)
#
# [Write a model to an input file](https://wntr.readthedocs.io/en/latest/waternetworkmodel.html#write-a-model-to-an-inp-file)
# +
# Changing the units
wn.options.hydraulic.inpfile_units = 'LPS'
# Writing a new INP-file, to do the convertion
wn.write_inpfile('Net1_project_SI.inp', version=2.2)
# Doing the same procedure as above, and assignning the new INP-file to a variable, to use when creating the model.
input_file = 'Net1_project_SI.inp'
wn = wntr.network.WaterNetworkModel(input_file)
# Plotting the network to check if the model looks ok
wntr.graphics.plot_network(wn)
# -
# # Task 1 Loading EPANET-file
# In this task, the goal is to load the EPANET input-file, and create the network model for use in the coming tasks.
# The task is divided into:
# * Install and import the `wntr-package`
# * Import and assign the EPANET input-file
# * Plot results from the simulation
# ### Task 1a: Installing wntr and importing
# Perform the following tasks:
# * Install the `wntr-package` (it should already be installed from the examples above)
# * Import the `wntr-package`
# * Import other relevant packages
# ### Task 1b: Importing and assigning the input file
# Perform the following tasks:
# * Import the EPANET input-file (INP-file)
# * Assing the input-file to create a Network model
# ### Task 1c: Change the units from US-customary to SI-based
# Perform the following tasks:
# * Check the units for the Hydraulics of the model
# * Change the units from US-customary to SI-based
# * Import and assign the new input-file
# # Query attributes
# The query function is a helpfull tool when you are searching for objects attributes. This could be the elevation of the nodes or the rougnesses of the pipes. You could also find the lowest or highest values within a attribute if you make it into a pandas series and utilize the `.ixmax()` or `.ixmin()` function. It is also possible to use the built in functions to find the sum of the attribute values.
#
# [Query element attributes](https://wntr.readthedocs.io/en/latest/waternetworkmodel.html#query-element-attributes)
#
# [Pandas: Idmax](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.idxmax.html#pandas.Series.idxmax)
#
# +
node_name = wn.query_node_attribute('name')
print(node_name)
link_length = wn.query_link_attribute('length')
print(link_length.sum())
# -
# # Color mapping
#
# You can also plot the network with the attributes of your choosing. If you would like the nodes in the plot to be colored accordning to the scale of the demand, elevation or head, you can just query the attribute and set it as the `node_attribute` parameter in `wntr.graphics.plot_network`. To decide what color scheme this should be in you can just write the name of the color scheme in to the `node_cmap` parameter. The names of the different color schemes can be found here: [Color maps](https://matplotlib.org/3.5.1/tutorials/colors/colormaps.html)
#
#
#
# For the links its a bit more complicated. you will have to import the color scheme instead of just typing the name of the color scheme. Use `plt.cm.COLOR` to import the scheme that you want to use in the `link_cmap` parameter.
#
# Documentation for network plotting: [Network](https://wntr.readthedocs.io/en/latest/graphics.html#networks)
#
#
# # Find attributes for spesific elements
# `wn.get_node(nodename)` and `wn.get_link(linkname)`can be used to to find the different attributes for a given node or link. This can be usefull if you just want to look up the elevation or coordinates for a single element at a time. Coordinates are returned as a tuple with x and y values.
#
print(wn.get_node('10').coordinates)
print(wn.get_link('10').length)
# # Task 2 Plotting water network
# In this task, the goal is to plot the water network, and perform some statistical analysis on some of the network attributes.
# The task is divided into:
# * Finding the node attributes
# * Finding the link attributes
# * Plotting the network with different attributes
# ### Task 2a: Finding node attributes: elevation, names, demand
# Perform the following tasks:
# * Find the elevation and name of the highest node
# * Find the demand at the highest node
# * Make a print of the name of the highest node
#
# ### Task 2b: Findig link attributes: diameter, lenght, coordinates of link
# Perform the following tasks:
# * Query the diameters of the pipes
# * Calculate and make a print of the mean pipe diameter
# ### Task 2c: Plotting the network with attributes and color map (links and nodes)
# Perform the following tasks:
# * Choose a colormap to use for the attributes of the network. "Unlimited" colormaps can be found at ([Matplotlib_Colormaps](https://matplotlib.org/3.5.1/tutorials/colors/colormaps.html)).
# * Plot the network with elevation as node attribute and diameter as link attribute
# * Mark the node with highest elevation, using a star as the marker
#
# Remember to have a title on the network, and attribute labels
# ## Running a steady-state simulation in WNTR
# With a steady state simulation, the system is observed at a specific point in time or under steady-state conditions (flow rates and hydraulic grades remain constant over time). This analysis is useful to determine the network behaviour during minimum, maximum or average flowrates ([Bentley WaterGEMS CONNECT](https://docs.bentley.com/LiveContent/web/Bentley%20WaterGEMS%20SS6-v1/en/GUID-F61F2CDD6AFD4451B0C56A18708E806A.html)).
# When doing analysis in EPANET and WNTR, we need to choose which demand model we want to use for the simulation. The choice is between `Demand Driven Analysis (DDA)` and `Pressure Driven Analysis (PDA)`. The two analyze methods is quite different, so be sure on which one you are using when. We will use the DDA-method in this Notebook.
#
# If you want to learn more about the different types of analysis, check this link: [EPANET Documentation](https://epanet22.readthedocs.io/en/latest/8_analyzing_network.html)
#
# In WNTR we also have two choices for the
# +
# Choose the type of solver you want to use, here we will use Demand Driven.
wn.options.hydraulic.demand_model = 'DDA'
# Running a simulation
# We usually call the simulation variable sim for simplicity, but you could in theory call it whatever you want.
#
sim = wntr.sim.EpanetSimulator(wn)
results = sim.run_sim()
# -
# All the results from the simulation is now stored in the variable named `results`. For us to do analyzes or visualize the results, we need to extract the data we need.
# ## Showing the results from the simulation
# Now we want to look at the results from the steady-state simulation above. Let' look at the DataFrame of the pressure in the nodes. The different results is mainly divided into results for the links and results for the nodes. We need to specify if the result we want to obtain is at a link or in a node. It's also important to write the correct name of the result you want, like 'pressure' or 'flowrate' etc, so it's recommended that you get familiar with the names EPANET and WNTR are using.
# +
# Making a variable to store the pressure from the results.
# Since pressure is a node result, we need to specify that we want to collect results from the nodes.
# We then specify that we want the pressure.
pressure = results.node['pressure']
# Using the Pandas function display() to get a better print of the results
display(pressure)
# -
# In the DataFrame above, the row shows the timestep of the simulation, which is zero in our case due to the fact that it is a steady-state simulation, and we are only looking into one timestep. The columns shows the different nodes.
# If we want to have the nodes as rows and the timestep as columns (useful for extended-period simulation results and plotting), we can transpose the DataFrame.
# Transposing the DataFrame to get nodes as rows, and timestep as column, using the .T function
pressure_transposed = pressure.T
display(pressure_transposed)
# ## Plotting simulation results
# It is possible to plot the values of DataFrames, meaning that we can get some good visualisations of our results. Lets make a plot of the simulated pressures, having the nodes on the x-axis, and the pressure on the y-axis.
#
# NB! Remember to always have axis names, legends, titles and units on the plot, enough to make it clear what the plot is showing us.
# +
# Creating a list with all the node names, to use when plotting.
node_names = []
for i in range(0, 11):
node_names.append(pressure.T.index[i])
plt.plot(node_names, pressure.T, marker='o', label='Steady-State simulation')
plt.title('Simulated pressures')
plt.legend()
plt.grid()
plt.xlabel('Node names', fontsize=12)
plt.ylabel('Simulated pressure (m)', fontsize=12)
plt.xlim(0, len(node_names) - 1)
plt.ylim(0, 100);
# We could also use the Pandas function .plot(), to easily plot the pressure results.
# Try it yourself!
# pressure.T.plot(title='Steady-State simulation')
# -
# To get a even better view of the network, we can plot the water network model, and use our simulation results as attributes. This way we can see where the nodes from the plot above are located in the network.
# Plotting the network, showing pressure at the nodes, with a range from 20 m to 100 m.
wntr.graphics.plot_network(wn, node_attribute=pressure.loc[0,:],
title='Steady-State simulation',
node_size=75,
node_range=[20, 100],
node_colorbar_label='Pressure (m)',
node_labels=node_names
)
# # Task 3 Simulating water network
# In this task, the goal is to run the first simulation of the network. The task is divided into:
# * Running the simulation
# * Show results from the simulation
# * Plot results from the simulation
#
#
# ### Task 3a Steady state simulation
# Perform the following tasks:
# * Run the simulation, using the EpanetSimulator and a demand-driven simulation
# * Store the resulting simulation in a variable with a suitable name
# ### Task 3b Show simulation results
# Perform the following tasks:
# * Display a Pandas Dataframe with the simulated Flowrate at the links
# * Display a Pandas Dataframe with the simulated Velocity at the links
# * Display a Pandas Dataframe with the simulated Pressures at the nodes
# ### Task 3c Plotting the results and the network
# Perform the following tasks:
# * Make plots of the simulation results from the previous task (Task 3b), having the link/node-names on the x-axis and the simulated results on the y-axis
# * Plot the network with pressure as node attribute and flowrate as link attribute
# # Finding single attributes
#
# It might be usefull to change different attributes within your nettwork, either to calibrate the nettwork or to see what the changes could do to your nettwork. Some examples of these attributes are demand, dimension, pipe roughness or initial status. To do changes to the attributes you will have to use `wn.get_link` or `wn.get_node` in a simmilar method as shown in the example below.
#
# Set a new value for the roughness
pipe = wn.get_link('10')
pipe.roughness = 130
print(pipe.roughness)
# It is also possible to be more precise when you are using the query function. You can define what kind of element type that you want to query and you can use numpy functions to define what values you would like to query. Which could be usefull to find all the pipes with a lenght greater than, lower than or equal to a given value. Instead of including every link, like the valves and pumps you can set `link_type = wntr.network.model.Pipe`
#
#
# [Query documentation](https://wntr.readthedocs.io/en/latest/waternetworkmodel.html#query-element-attributes)
#
# Another important thing to note while you are changing the attributes, is that you can itterate trough the pipes and change every pipe with a for loop that itterates over `wn.pipes()`, you could eg. change the roughnesses for all the pipes.
#
# [Itterate over elements](https://wntr.readthedocs.io/en/latest/waternetworkmodel.html#iterate-over-elements)
#
# # Task 4 Change attributes
#
# In this task, the goal is to do some changes to the attributes of the network, and see how it affects the behaviour of the system. The task is divided into:
# * Running the simulation
# * Show results from the simulation
# * Plot results from the simulation
# ### Task 4a: Change dimension of some pipes
# Perform the following tasks:
# * Query how many pipes that has a dimension less than 350 mm
# * Change the diameter of all pipes with diameter less than 350mm, to a diameter of 350mm
# * Do a check to see if there is still any pipes with diameter lower than 350mm.
# ### Task 4b: Change initial status of some links
# Perform the following tasks:
# * Check if there are any pipes with status set to 'closed' in the network
# * There is schedueld a maintenance on link "335", so you will have to close this link
# * Open the initialy closed pipe that you found
#
# ### Task 4c: Run steady-state simulations with changed attributes
# Perform the following tasks:
# * Simulate the nettwork with the maintenance going on and plot the results
# ## Running an extended-period simulation in WNTR
# When running an extended-period simulation, we need some more input than with a steady-state simulation. To be able to create timesteps with different demands throughout a specific time, we need to add demand patterns to the nodes of the system.
# ## Check and modify patterns in the model
# We can check if there is any existing patterns in the system by using the `wn.pattern_name_list` function.
# +
# Making a variable containing all patterns of the system.
patterns_network = wn.pattern_name_list
# Making a print to show how many patterns we have and what they are called
print(f'We got {len(patterns_network)} pattern with the name {patterns_network}')
# -
# It is possible to add new patterns, which will be done in task 6. We will make a new multiplier to the excisting pattern in the system.
#
# We will make a pattern of a 6 hour cycle throughout a whole day, which results in 4 numbers in the multiplier.
# +
# Making a variable out of the pattern name, based on the results
# in the codecell above.
pattern = wn.patterns.get('1')
# Creating a multiplier to use in the pattern
pattern_multiplier = [1, 1.4, 1.8, 1.2]
# Changing from the excisting multiplier to the new multiplier
# by using the .multipliers function.
pattern.multipliers = pattern_multiplier
# Collecting the patterns to check that we have the correct multiplier.
wn.patterns.get('1')
# -
# ## Check and modify timesteps in the model
# To be able to get the timesteps we want from the simulation, we need to check and change the timesteps in the model. Start by writing `wn.options.time` and press `tab` to see which timestep options there is in the model.
#
# We need to modify `report_timestep`, `pattern_timestep` and `duration` to get the wanted timesteps in the simulation. Remember that time is given in seconds!
# +
# Setting the timestep to correspond to 6 hour cycles
wn.options.time.report_timestep = 3600 * 6
wn.options.time.pattern_timestep = 3600 * 6
# Setting the total duration of the simulation, 24 hours
wn.options.time.duration = 3600 * 24
# -
# Now everything is set to run the extended period simulation. As seen from above, the difference from a steady-state simulation is the patterns and timesteps.
# Below we will run the simulation.
# +
# Setting the hydraulic demand model, demand-driven in this case
wn.options.hydraulic.demand_model = 'DDA'
# Running the simulation
sim = wntr.sim.EpanetSimulator(wn)
results = sim.run_sim()
# Extracting the pressure results from the simulation
sim_pressure = results.node['pressure']
# Changing the time unit from seconds to hours in the DataFrame
sim_pressure.index = sim_pressure.index / 3600
display(sim_pressure)
# -
# Now we can plot the results we want to visualize.
# Plotting the pressure in one of the nodes
sim_pressure['10'].plot()
plt.grid()
plt.xlabel('Time (hours)', fontsize=14)
plt.ylabel('Pressure (m)', fontsize=14)
plt.title('Pressure at node 10')
plt.xlim(0, 24)
# # Task 5 Change and add patterns
# In this task, the goal is to change and add demand patterns at the nodes. The task is divided into:
#
# * Change a pattern by adding multipliers
# * Perform an extended period simulation
# * Plotting results of extended period simulation
# ### Task 5a: Change the existing pattern
# Perform the following tasks:
# * Find the existing pattern
# * Add a multiplier to the existing pattern. Create a multiplier corresponding to a demand pattern of 2 hour intervals, for a total of 24 hours.
# ### Task 5b: Extended period simulation
# Perform the following tasks:
# * Check the pre-defined timesteps from the INP-file
# * Change the report timestep and the pattern timestep to correspond with the demand pattern.
# * Set the timesteps for the simulation
# * Run the simulation with the `Demand Driven solver`
# * Store the simulation results in a variable
# ### Task 5c: Showing results from the simulation
# Perform the following tasks:
# * Display the simulation results (pressure, demand) in a Pandas Dataframe
# * Choose a node to use for the plots
# * Plot the pressure for the period for the choosen node, with time on the x-axis and pressure on the y-axis
# * Plot the demand for the periode for the choosen node, with time on the x-axis and demand on the y-axis
#
# Remember to make a describing plot, with titles, labels and units.
# # Task 6 Creating a network from scratch (Optional)
# To fully understand how to modify your nettwork it could be handy to know how to make a nettwork from scratch. This can be done in a simple way.
#
# As mentioned above, you should initialy create a pattern such that you can do extended period simmulations. This can be done with `wn.add_pattern`. The next step in making your own nettwork is to add junctions. You can add junctions with `wn.add_junctions`. Instead of simply having a network with just junctions and demands, you could also add a water supply as reservoirs or tanks. To do this you can use a simmilar function to junctions `wn.add_reservoir` or `wn.add_tank`.
#
# The path between the nodes is defined as links and could be set as either pipes, valves or pumps. This could be done with `wn.add_pipe`, where you decide what nodes it should connect between. If you want to further use this water nettwork, you could write this to a input file as mentioned in taks 1.
#
# [Documentation on how to build a model](https://wntr.readthedocs.io/en/latest/waternetworkmodel.html#build-a-model-from-scratch)
#
# NB! Remember that there is a difference between setting the demand in EPA-Net and in WNTR. EPA-Net demand is in $\frac{L}{s}$ and WNTR uses $\frac{M^3}{s}$
#
#
# * Make a network with a minimum of 4 nodes and a watersupply with connections between them
# * Write your network to a inputfile
# * Try to open your file in EPA-Net
# # Solutions to the tasks
# ## Task 1 Loading EPA-NET file
# ### Task 1a: Installing wntr and importing
# !pip install wntr
import wntr
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
# ### Task 1b: Importing and assigning the input file
input_file = 'Net3_uncalibrated.inp'
wn = wntr.network.WaterNetworkModel(input_file)
wntr.graphics.plot_network(wn, title=wn.name)
wn.describe(level=1)
# ### Task 1c: Change the units from imperical to SI
wn.write_inpfile('Net3_changed_units.inp', version=2.2, units='LPS')
input_file = 'Net3_changed_units.inp'
wn = wntr.network.WaterNetworkModel(input_file)
# ## Task 2 Plotting water network
# ### Task 2a: Finding node attributes: elevation, names, demand
node_elevation = wn.query_node_attribute('elevation')
node_elevation = pd.Series(node_elevation)
highest_node = node_elevation.idxmax()
print('The name of the highest node is:', highest_node)
#
# ### Task 2b: Findig link attributes: diameter, roughness, lenght, coordinates of link
link_diameter = wn.query_link_attribute('diameter')
test_2 = link_diameter.mean()
print('The mean pipe diameter is', f'{test_2:.3f}','mm')
# ### Task 2c: Plotting the network with attributes and color map (links and nodes)
# +
link_colormap = plt.cm.rainbow
wntr.graphics.plot_network(wn,
title='Water network 3',
node_size=15,
link_cmap=link_colormap,
node_cmap='rainbow',
node_attribute=node_elevation,
link_attribute=link_diameter,
link_colorbar_label='Diam',
node_colorbar_label='Elev');
n = wn.get_node(highest_node)
x, y = n.coordinates
plt.plot(x,y, 'k*', markersize=10, markerfacecolor='None', markeredgewidth=0.8)
plt.show()
# -
# ## Task 3 Simulating water nettwork
# ### Task 3a: Steady state simulation
# +
# Choose the type of solver, demand-driven here
wn.options.hydraulic.demand_model = 'DDA'
# Running a simulation
sim = wntr.sim.EpanetSimulator(wn)
results = sim.run_sim()
# -
# ### Task 3b: Show simulation results
# +
# Flowrate in links
flowrate = results.link['flowrate']
display(flowrate)
# Veloctiy in links
velocity = results.link['velocity']
display(velocity)
# Pressure in nodes
pressure = results.node['pressure']
display(pressure)
# -
# ### Task 3c: Plotting results (pressure distibution) Nettwork plot with pressure as attribute
# +
# Flowrate plot
flowrate.T.plot()
plt.ylabel('Flowrate (l/s)')
plt.xlabel('Link name')
plt.legend(labels='Q')
plt.title('Flowrate in links')
plt.grid()
# Velocity plot
velocity.T.plot()
plt.ylabel('Velocity (m/s)')
plt.xlabel('Link name')
plt.legend(labels='v')
plt.title('Velocity in links')
plt.grid()
# Pressure plot
pressure.T.plot()
plt.ylabel('Pressure (m)')
plt.xlabel('Node name')
plt.title('Pressure in nodes')
plt.grid()
# +
# Extracting the flowrate and pressure from the results
# To use in the plot.
flowrate = results.link['flowrate'].loc[0,:]
pressure = results.node['pressure'].loc[0,:]
# Plot of the network, pressure at nodes and flowrate in links
wntr.graphics.plot_network(wn, node_attribute=pressure,
link_attribute=flowrate,
node_colorbar_label='Pressure (m)',
link_colorbar_label='Flowrate (l/s)')
# -
# ## Task 4 Change attributes
# ### Task 4a: Change dimension of some pipes
# +
links_under = wn.query_link_attribute('diameter', np.less, 350, link_type=wntr.network.model.Pipe)
print(len(links_under), 'pipes has a dimension less than 350 mm')
for pipe_name, pipe in wn.pipes():
if 0 < pipe.diameter <= 0.35:
pipe.diameter = 0.35
else:
pass
links_under = wn.query_link_attribute('diameter', np.less, 350, link_type=wntr.network.model.Pipe)
print(f'After the change, {len(links_under)} pipes has a dimension less than 350 mm')
# -
# ### Task 4b: Change initial status
# +
for pipe_name, pipe in wn.pipes():
test = str(pipe.status)
if test == 'Closed':
closed_pipe = pipe
print(f'The pipe named "{closed_pipe}" is closed')
# Task 4b, Alternative method
# closed_pipes = wn.query_link_attribute('status', np.equal, 0, link_type=wntr.network.model.Pipe)
# for element in closed_pipes.index:
# print(f'The pipe named "{element}" is closed')
closed_pipe.initial_status = 'Opened'
print(f'The pipe is now "{closed_pipe.initial_status}"')
pump = wn.get_link(335)
pump.initial_status = 'Closed'
print(f'The pump is now "{pump.initial_status}"')
# -
# ### Task 4c: Run steady-state simulations with changed attributes
# +
sim = wntr.sim.EpanetSimulator(wn)
results = sim.run_sim()
pressure = results.node['pressure'].loc[0,:]
wntr.graphics.plot_network(wn, node_attribute=pressure,
title='Steady-State simulation',
node_size=25,
node_range=[20, 100],
node_colorbar_label='Pressure (m)');
# -
# ## Task 5 Change and add patterns
# ### Task 5a: change the added pattern
# +
patterns_network = wn.pattern_name_list
print(f'We got {len(patterns_network)} pattern with the name {patterns_network}')
pattern = wn.patterns.get('1')
pattern_multiplier = [0.25, 0.50, 0.75, 1.75, 1.5, 1.25,
1, 1.25, 2, 1.50, 1.25, 0.75]
print(len(pattern_multiplier))
pattern.multipliers = pattern_multiplier
wn.patterns.get('1')
# -
# ### Task 5b: Adding timesteps and simulate
# +
# Changing the timesteps
wn.options.time.report_timestep = 3600 * 2
wn.options.time.pattern_timestep = 3600 * 2
wn.options.time.duration = 3600 * 24
# Setting the hydraulic demand model
wn.options.hydraulic.demand_model = 'DDA'
sim = wntr.sim.EpanetSimulator(wn)
results = sim.run_sim()
# -
# ### Task 5c: Showing results from the simulation
# +
# Pressure results
sim_pressure = results.node['pressure']
sim_pressure.index = sim_pressure.index / 3600
display(sim_pressure)
# Demand results
sim_demand = results.node['demand']
sim_demand.index = sim_demand.index / 3600
display(sim_demand)
# +
# Using node 101 further in the proposed solution
# Plotting the pressure for node 101
sim_pressure['101'].plot()
plt.grid()
plt.xlabel('Time (hours)', fontsize=14)
plt.ylabel('Pressure (m)', fontsize=14)
plt.xlim(0, 24)
plt.title('Simulated pressure at node 101')
# -
# Plotting the demand for node 101
sim_demand['101'].plot()
plt.grid()
plt.xlabel('Time (hours)', fontsize=14)
plt.ylabel('Demand (l/s)', fontsize=14)
plt.xlim(0, 24)
plt.title('Simulated demand at node 101')
# ## Task 6 Creating a network from scratch
# +
wn = wntr.network.WaterNetworkModel()
# Patterns
wn.add_pattern('pat1', [1])
wn.add_pattern('pat2', [1,2,3,4,5,6,7,8,9,10])
# Junctions
wn.add_junction('node1', base_demand=1, demand_pattern='pat1', elevation=50, coordinates=(1,2))
wn.add_junction('node2', base_demand=1, demand_pattern='pat1', elevation=42, coordinates=(1,3))
wn.add_junction('node3', base_demand=1, demand_pattern='pat1', elevation=37, coordinates=(1,1))
wn.add_junction('node4', base_demand=1, demand_pattern='pat2', elevation=38, coordinates=(2.5,2.3))
# Reservoirs
wn.add_reservoir('res', base_head=125, head_pattern='pat1', coordinates=(0,2))
# Pipes
wn.add_pipe('pipe0', 'node1', 'res', length=100, diameter=0.3, roughness=100, minor_loss=0.0, initial_status='OPEN')
wn.add_pipe('pipe1', 'node1', 'node2', length=200, diameter=0.3, roughness=100, minor_loss=0.0, initial_status='OPEN')
wn.add_pipe('pipe2', 'node2', 'node4', length=400, diameter=0.3, roughness=100, minor_loss=0.0, initial_status='OPEN')
wn.add_pipe('pipe3', 'node4', 'node3', length=400, diameter=0.3, roughness=100, minor_loss=0.0, initial_status='OPEN')
wn.add_pipe('pipe4', 'node1', 'node3', length=200, diameter=0.3, roughness=100, minor_loss=0.0, initial_status='OPEN')
wn.add_pipe('pipe5', 'node1', 'node4', length=300, diameter=0.3, roughness=100, minor_loss=0.0, initial_status='CLOSED')
wntr.graphics.plot_network(wn)
wn.write_inpfile('network_from_cratch.inp', units='LPS', version=2.2)
|
# -*- coding: utf-8 -*-
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .jl
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Julia 1.2.0
# language: julia
# name: julia-1.2
# ---
using CarrierCapture
using Plots, LaTeXStrings
using DataFrames
# # Potentials
Qmin = -5
Qmax = 35
NQ = 3000
Q = range(Qmin, stop=Qmax, length=NQ)
# +
# pot1
nev = 30
name = "d0+e+h"
Q1 = [0.0000 0.8070 1.6142 2.4214 3.2286 4.0357 4.8428 5.6501 6.4571 7.2643 8.0715 8.8787 9.6857 10.4930 11.3000 12.1072 12.9144 13.7215 14.5287 15.3359 16.1430 16.9502 17.7574 18.5644 19.3716 20.1788 20.9859 21.7931 22.6002]
E1 = [-953.1843 -991.3164 -1019.6837 -1041.2625 -1058.1281 -1070.3129 -1078.6854 -1084.3352 -1088.1507 -1090.7382 -1092.4813 -1093.6187 -1094.3120 -1094.6724 -1094.7791 -1094.6931 -1094.4715 -1094.2920 -1094.1575 -1094.0447 -1093.9488 -1093.8619 -1093.7599 -1093.6182 -1093.4127 -1093.1290 -1092.7661 -1092.3560 -1091.9551]
pot1 = potential(); pot1.name = name
pot1.nev = nev
pot1.Q0 = Q1[findmin(E1)[2]]; pot1.E0 = 1.69834
pot1.QE_data = DataFrame(Q = Q1[:], E = E1[:])
pot1.QE_data.E .+= - minimum(pot1.QE_data.E) + pot1.E0
pot1.Q = Q
pot1.func_type = "bspline"
fit_pot!(pot1, Q)
# pot2
nev = 60
name = "DX-+h"
# spline fitting parameters
order = 4
smoothness = 0.001
weight = [1 1 1 1 1 0.5 0.4 0.4 0.5 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
Q2 = [30.66721918 29.860133 29.05306268 28.24612992 27.43911044 26.63197583 25.82507425 25.01797262 24.21096115 23.40387798 22.59690043 21.78991117 20.98281579 20.17570172 19.36884219 18.56169249 17.75463179 16.94772679 16.14061031 15.33347439 14.52663309 13.71945696 12.91240658 12.10544441 11.29841968 10.4913338 9.684370388 8.877289725 8.070184138]
E2 = [8.0902 7.5970 7.0749 6.5242 5.9461 5.3451 4.7300 4.1147 3.5182 2.9637 2.4769 2.0819 1.7972 1.6315 1.5800 1.6237 1.7301 1.8586 1.9687 2.0283 2.0190 2.0673 1.9910 2.0528 1.9730 2.0857 2.4550 3.1653 4.3448]
pot2 = potential(); pot2.name = name
pot2.nev = nev
pot2.Q0 = Q2[findmin(E1)[2]]; pot2.E0 = 1.69834
pot2.QE_data = DataFrame(Q = Q2[:], E = E2[:])
pot2.QE_data.E .+= - minimum(pot2.QE_data.E) + pot2.E0
pot2.Q = Q
pot2.func_type = "spline"
params = Dict()
params["order"] = order
params["smoothness"] = smoothness
params["weight"] = weight
fit_pot!(pot2, Q; params=params)
# pot3
nev = 110
name = "d0"
pot3 = potential(); pot3.name = name
pot3.nev = nev
pot3.Q0 = Q1[findmin(E1)[2]]; pot3.E0 = 0
pot3.QE_data = DataFrame(Q = Q1[:], E = E1[:])
pot3.QE_data.E .+= - minimum(pot3.QE_data.E) + pot3.E0
pot3.Q = Q
pot3.func_type = "bspline"
fit_pot!(pot3, Q; params=params)
solve_pot!(pot1)
solve_pot!(pot2)
solve_pot!(pot3)
# -
# ### Capture barriers
Qx, Ex = find_crossing(pot1, pot2)
println("Electron capture barrier: $(Ex-pot1.E0) eV")
Qx, Ex = find_crossing(pot2, pot3)
println("Hole capture barrier: $(Ex-pot2.E0) eV")
# ### Potentials and associated wave functions
plt = Plotter.plot_pot!(pot1; lplt_wf = false, color = "#b2182b")
Plotter.plot_pot!(pot2; lplt_wf = false, plt = plt, color = "#2166ac")
Plotter.plot_pot!(pot3; lplt_wf = false, plt = plt, color = "#b2182b")
xlims!((5, 25))
ylims!((-0.2, 3.7))
# # Capture coefficient
Cmin = 1E-20
Cmax = 1E-5
invTmin = 1
invTmax = 13
Tmin = 10
Tmax = 800
NT = 100
Volume = 4.72276E-21
cut_off = 0.25
σ = 0.01
temperature = range(Tmin, stop=Tmax, length=NT)
# ## Electron capture
# +
W = 0.0675 # e-ph coupling
g = 1 # degeneracy
# build a configuration coordinate for the electron capture
cc_e = conf_coord(pot1, pot2)
cc_e.W = W
cc_e.g = g
calc_overlap!(cc_e; cut_off = cut_off, σ = σ)
calc_capt_coeff!(cc_e, Volume, temperature)
# -
# ## Hole capture
# +
W = 0.0217 # e-ph coupling
g = 1 # degeneracy
# build a configuration coordinate for the electron capture
cc_h = conf_coord(pot2, pot3)
cc_h.W = W
cc_h.g = g
calc_overlap!(cc_h; cut_off = cut_off, σ = σ)
calc_capt_coeff!(cc_h, Volume, temperature)
# +
plt = plot()
Plotter.plot_cc!(cc_e; plt=plt, label="electron capture")
Plotter.plot_cc!(cc_h; plt=plt, label="hole capture")
xlims!(1, 13)
ylims!(1E-29, 1E-7)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [Root]
# language: python
# name: Python [Root]
# ---
# # The Basics - Variables and Printing
# +
hello_text = "Hello World"
# Print Hello World - this is a comment!
print(hello_text)
# +
n = 12
f = 0.1
print(f + n)
# +
s1 = "Hello World"
s2 = 'Hello Universe'
print(s1 + "\n" + s2)
# -
print("n=" + str(n) + " f=" + str(f))
print("n=%d" % d)
print("f=%f" % f)
print("n=%d f=%f" % (d,f))
# +
first_name = "Alice"
last_name = "McMillan"
print("{0} {1}".format(first_name,last_name))
print("{1}, {0}".format(first_name,last_name))
# -
# # Types
type(7)
type(2.7)
type("Hello world")
type(True)
type(None)
# # Arrays
# +
a = [1,2,3,4]
print(a)
# -
type(a)
len(a)
# ## Accessing Array Elements
a[0]
a[1]
a[3]
a[4]
a[-1]
a[-4]
# ## Slices of Arrays
a[1:]
a[:3]
a[1:2]
a[:]
a[-1:]
a[:-1]
# ## Editing Arrays
a = [1,2,3,4]
a[2] = 7
a
a[1:2] = [5555]
a
a[1:2] = [555,6666]
a
del a[2]
a
del a[1:3]
a
# # Tuples
x = ("Hello","world")
print(x)
type(x)
len(x)
x[0]
(a,b) = ("Hello","world")
print(a,b)
print(*x)
# # Sets and Dictionaries (Maps)
names = {"Alice", "Bob"}
names
len(names)
type(names)
'Alice' in names
'Charles' in names
# ## Dictionaries
birthdays = {"Alice":"1963/06/02", "Bob":"1965/08/12"}
birthdays
len(birthdays)
type(birthdays)
'Alice' in birthdays
birthdays['Alice']
birthdays["Charlie"] = "1967/09/13"
birthdays["Charlie"]
del birthdays["Bob"]
birthdays
# # Functions
# +
def print_birthday(name):
bday = birthdays[name]
print("%s is born on %s" % (name, bday))
print_birthday('Alice')
# -
print_birthday("Bob")
# # Conditions
# +
def print_birthday(name):
if name in birthdays:
bday = birthdays[name]
else:
bday = "<unknown>"
print("%s is born on %s" % (name, bday))
print_birthday("Alice")
# -
print_birthday('Bob')
# ## Alternative Implementation
# +
def print_birthday(name):
bday = birthdays.get(name, "<unknown>")
print("%s is born on %s" % (name, bday))
print_birthday("Alice")
print_birthday("Bob")
# -
# # Loops
for name in names:
print_birthday(name)
# ## Ranges
for i in range(1,10):
if i % 2 != 0:
print("%d is odd" % i)
else:
print("%d is even" % i)
i = 0
while (i < 10):
print(i)
i += 1
i = 0
while(True):
print(i)
i += 1
if (i >= 10):
break
# # Classes and Objects
class Person:
def set_name(self, name):
self.name = name
def get_name(self):
return self.name
alice = Person()
alice.set_name("Alice")
print(alice.get_name())
type(alice)
bob = Person()
print(bob.get_name())
class Person:
def __init__(self, name=""):
self.name = name
def set_name(self, name):
self.name = name
def get_name(self):
return self.name
alice = Person("Alice")
print(alice.get_name())
bob = Person()
print(bob.get_name())
# ## Inheritance
# +
class Shape:
def get_area(self):
return 0
def get_circumference(self):
return 0
def show(self):
print("Area=%f, Circumference=%f" %(self.get_area(), self.get_circumference()))
class Box(Shape):
def __init__(self, a, b):
self.a = a
self.b = b
def get_area(self):
return self.a*self.b
def get_circumference(self):
return 2*(self.a+self.b)
class Circle(Shape):
def __init__(self,r):
self.r = r
def get_area(self):
return 3.141*self.r*self.r
def get_circumference(self):
return 2*3.141*self.r
# +
box = Box(2,3)
box.show()
circle = Circle(4)
circle.show()
# -
isinstance(box,Box)
isinstance(box,Shape)
isinstance(box,Circle)
# # Exceptions
try:
1/0
except Exception as ex:
print("Error: " + str(ex))
print(type(ex))
try:
raise BaseException("This is an error")
except BaseException as s:
print(s)
try:
pass
# raise BaseException("This is an error")
except BaseException as s:
print(s)
finally:
print("Finally here")
# # Modules
# +
import decimal
d = decimal.Decimal(12)
print("d=%f" % d)
# +
from decimal import Decimal
d2 = Decimal(13.123)
print("d2 as int: %2", d2)
# +
from math import *
print(sqrt(2))
# -
# # List Comprehension
[2*x for x in range(0,10)]
# # Map & Filter
# ## Mapping
# +
def square(x):
return x*x
s = map(square, range(1,10))
s
# -
[n for n in s]
[n for n in s]
for n in map(square, range(1,10)):
print(n)
# ## Filtering
# +
def is_even(x):
return x % 2 == 0
evens = filter(is_even, range(1,10))
evens
# -
[e for e in evens]
# ## Reducing
# +
from functools import reduce
def add(x,y):
return x + y
reduce(add, range(1,10))
# -
# # Lambda Functions
# +
square = lambda x: x*x
s = map(square, range(1,10))
for n in s:
print(n)
# -
for n in map(lambda x: x*x, range(1,10)):
print(n)
# # Generator Functions
# +
def generator(r):
for x in r:
print("Evaluate for %d" % x)
yield x*x
squares = generator(range(1,10))
squares
# -
for x in squares:
print(x)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3.6 + GPU
# language: python
# name: python3
# ---
# + id="va0dDcl0Dx7t" colab_type="code" colab={}
import re
import pandas as pd
import numpy as np
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# + [markdown] id="noAQfbyWD9Qd" colab_type="text"
# ## Fetch the tweets
#
# Load in a collections of tweets. These tweets were downloaded from Twitter's streaming API over a number of hours for any tweets containing the words *happy*, *sad*, *joy*, *anger*, *angry*
# + id="49d0fIF9Dx73" colab_type="code" colab={}
df = pd.read_csv("https://github.com/IBMDeveloperUK/ML-For-Everyone/blob/master/20200609-Analysing-Tweet-Sentiment-with-Keras/tweets.csv.gz?raw=true", compression='gzip')
df.dropna(inplace=True)
# + id="WkxaFpNYDx78" colab_type="code" colab={} outputId="8eba821f-51b6-4b48-f3db-be0da4e9e3a3"
df.head(5)
# + [markdown] id="31Csmia6ERC2" colab_type="text"
# ## Pre-process the tweets
#
# We need to tokenise the tweets, and categorise the tweets into the two classes we will be predicting *joy* and *anger*
# + id="U4dbTkwNDx8D" colab_type="code" colab={} outputId="93fd2006-7092-47a1-b85f-48b22bf37da1"
df2 = pd.DataFrame()
tkn = Tokenizer()
df2['tweet'] = df['Tweet']
tkn.fit_on_texts(df2['tweet'])
vocab_size = len(tkn.word_index) + 1
print(vocab_size)
df2['tkns'] = tkn.texts_to_sequences(df2['tweet'])
joy_re = re.compile(r"\b((?<!no )joy|(?<!not )happy|not sad|not angry|no anger)\b", re.I)
anger_re = re.compile(r"\b((?<!not )sad|(?<!not )angry|(?<!no )anger|not happy|no joy)\b", re.I)
df2['joy'] = df2['tweet'].apply(lambda x: 1 if re.search(joy_re, x) else 0)
df2['anger'] = df2['tweet'].apply(lambda x: 1 if re.search(anger_re, x) else 0)
df2.head(5)
# + [markdown] id="uE4JcCMqEmAs" colab_type="text"
# Calculate the length of each tweet, then calculate the 99% quantile for length and we will use that as the maximum length of the tweets we will process
# + id="7YECW6qODx8J" colab_type="code" colab={} outputId="dc7ea3df-737a-4e09-e284-0534006dc0cd"
df2['len'] = df2['tkns'].apply(lambda x: len(x))
df2.head(5)
# + id="MfCxskr9Dx8N" colab_type="code" colab={} outputId="62c5cb6d-128e-49a6-a48b-65701fda090c"
max_len = int(df2['len'].quantile(0.99))
max_len
# + [markdown] id="EzvA_Hj9E1tS" colab_type="text"
# ## Pre-trained word vectors
#
# We will be using the GloVe pre-trained word vectors from:
#
# https://nlp.stanford.edu/projects/glove/
#
# There is a specific collection collated from Twitter. This is downloadable as a zip file of CSV data. For usage below the 100 vector set has been converted to a python dictionary mapping word to a size (100,) numpy array and then pickled.
# + id="46crfZgfDx8S" colab_type="code" colab={}
import types
import pandas as pd
from botocore.client import Config
import ibm_boto3
def __iter__(self): return 0
# @hidden_cell
# The following code accesses a file in your IBM Cloud Object Storage. It includes your credentials.
# You might want to remove those credentials before you share the notebook.
client_32ba12f9aedd46c2a5230b8cb8fe2d3f = ibm_boto3.client(service_name='s3',
ibm_api_key_id='<fill in API Key>',
ibm_auth_endpoint="https://iam.cloud.ibm.com/oidc/token",
config=Config(signature_version='oauth'),
endpoint_url='https://s3-api.us-geo.objectstorage.service.networklayer.com')
# Your data file was loaded into a botocore.response.StreamingBody object.
# Please read the documentation of ibm_boto3 and pandas to learn more about the possibilities to load the data.
# ibm_boto3 documentation: https://ibm.github.io/ibm-cos-sdk-python/
# pandas documentation: http://pandas.pydata.org/
streaming_body_1 = client_32ba12f9aedd46c2a5230b8cb8fe2d3f.get_object(Bucket='twitchdemos2-donotdelete-pr-8dngl3cqohbrop', Key='glove.pkl')['Body']
# add missing __iter__ method, so pandas accepts body as file-like object
if not hasattr(streaming_body_1, "__iter__"): streaming_body_1.__iter__ = types.MethodType( __iter__, streaming_body_1 )
# + id="FC1F4RrmDx8W" colab_type="code" colab={}
import pickle
embedding_index = pickle.loads(streaming_body_1.read())
# + id="BfU88SS4Dx8a" colab_type="code" colab={} outputId="6b59df3a-d0b2-43f0-f2a3-b9a13fc5ae2c"
# Test to see we have a vector for a common word, e.g. cat
embedding_index['cat']
# + [markdown] id="Dvsvck-SFg-s" colab_type="text"
# ## Create an Embedding Matrix
# We create an embedding matrix in which we convert the words into the integer token values from the tokenizers word index.
# + id="gXHhB-HTDx8e" colab_type="code" colab={}
embedding_matrix = np.zeros((vocab_size, 100), dtype=np.float32)
for word, i in tkn.word_index.items():
embedding_vector = embedding_index.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector
# + id="TuShmbDODx8i" colab_type="code" colab={}
# Pad the documents out to the same length, based on out max length calculated above
padded_docs = pad_sequences(df2['tkns'], maxlen=max_len, padding='post')
# + id="o82UKVIUDx8m" colab_type="code" colab={} outputId="0bc4a9c7-8e83-4888-e028-d44d02bd5cb7"
labels = df2[['joy', 'anger']].values
# inspect a single document to see if it looks reasonable
padded_docs[0]
# + id="Aht41ZxbDx8q" colab_type="code" colab={} outputId="6421e2d8-7531-446b-b880-70d99be839e5"
embedding_matrix.shape
# + [markdown] id="O75nR1NZF5b9" colab_type="text"
# ## Build and Train our model
#
# We build a neural network model with Keras. The model is a two layer LSTM model with dropout layers in between to prevent overfitting.
#
# The model is then trained and evaluated on the tweets
# + id="yMcWJbLbDx8t" colab_type="code" colab={} outputId="d7655eaf-9482-4e50-933f-231d7799147a"
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, CuDNNLSTM as LSTM, Dropout
from tensorflow.keras.layers import Embedding, Flatten
model = Sequential()
model.add(Embedding(vocab_size, 100, weights=[embedding_matrix], input_length=max_len, trainable=False))
model.add(LSTM(100, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(100))
model.add(Dropout(0.2))
model.add(Dense(2, activation='softmax'))
# compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# summarize the model
print(model.summary())
# + id="G9FKPxfPDx8y" colab_type="code" colab={} outputId="d208d090-00c8-4991-db4e-e5e652ddef9a"
keywords = tkn.texts_to_sequences(["joy happy sad angry anger"])[0]
keywords
# + id="T2Rc7eG7Dx82" colab_type="code" colab={}
thresh = int(len(padded_docs) * 0.8)
train_X, test_X = padded_docs[:thresh], padded_docs[thresh:]
train_y, test_y = labels[:thresh], labels[thresh:]
for keyword in keywords:
train_X = np.where(train_X == keyword, 0, train_X)
# + id="m2GdGnskDx85" colab_type="code" colab={} outputId="63898957-6221-495d-a19d-b33b6373f055"
train_X[-8]
# + id="OdVvObXtDx87" colab_type="code" colab={} outputId="de571053-1cbf-4245-e9d4-568f77beca48"
model.fit(train_X, train_y, epochs=20, verbose=1,
validation_split=0.1,
batch_size=128)
# + [markdown] id="dBlQv2_BGQ15" colab_type="text"
# ## Test our model
#
# We test our model on a random set of statements to see how the sentiment comes out from our model. The predictions return an array of [joy, anger] percentages for each statement
# + id="lZrOcsamDx8-" colab_type="code" colab={} outputId="4d59ff42-8781-44ea-a51d-45bcbfa2f2b0"
tweets = ["I love the world",
"I hate the world",
"I'm not happy about riots",
"I like ice cream"
]
tweet_docs = tkn.texts_to_sequences(tweets)
tweet_padded_docs = pad_sequences(tweet_docs, maxlen=max_len, padding='post')
model.predict(tweet_padded_docs)
# + id="_dJOB63JDx9B" colab_type="code" colab={}
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [Root]
# language: python
# name: Python [Root]
# ---
# ## Subsetting Data
# ### Working with pandas
# *Curtis Miller*
#
# In this notebook we will subset `Series` and `DataFrame`s in a variety of ways.
#
# We start by creating some `Series` and `DataFrame`s to work with.
import pandas as pd
from pandas import Series, DataFrame
import numpy as np
srs = Series(np.arange(5),
index=["alpha", "beta", "gamma", "delta", "epsilon"])
srs
srs[:2]
srs[["beta", "delta"]]
srs["beta":"delta"] # Select everything BETWEEN (and
# including) beta and delta
srs[srs > 3] # Select elements of srs greater than 3
srs > 3 # A look at the indexing object
# Consider the following code `Series`. Notice the index is the numbers between 0 and 4 rearranged.
# +
srs2 = Series(["zero", "one", "two", "three", "four"],
index=[3, 2, 4, 0, 1])
srs2
# -
# What will the following do?
srs2[2:4] # Ambiguous
srs2.iloc[2:4]
srs2.loc[2:4]
# Now let's work with `DataFrame`s.
df = DataFrame(np.arange(21).reshape(7, 3),
columns=['AAA', 'BBB', 'CCC'],
index=["alpha", "beta", "gamma", "delta",
"epsilon", "zeta", "eta"])
df
df.AAA
df['AAA']
df[['BBB', 'CCC']]
df.iloc[1:3, 1:2]
df.loc['beta':'delta', 'BBB':'CCC']
df.iloc[:, 1:3]
df.iloc[:, 1:3].loc[['alpha', 'gamma', 'zeta']] # Mixing
# +
df2 = df.iloc[:, 1:3].loc[['alpha', 'gamma', 'zeta']].copy()
df2
# -
# Let's now look at changing the contents of `DataFrame`s.
# +
df2['CCC'] = Series({'alpha': 11, 'gamma': 18, 'zeta': 5})
df2
# -
df2.iloc[1, 1] = 2
df2
df2.iloc[:, 1] = 0
df2
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# (MCUASINEW)=
# # 7.2 Métodos cuasi Newton
# ```{admonition} Notas para contenedor de docker:
#
# Comando de docker para ejecución de la nota de forma local:
#
# nota: cambiar `<ruta a mi directorio>` por la ruta de directorio que se desea mapear a `/datos` dentro del contenedor de docker.
#
# `docker run --rm -v <ruta a mi directorio>:/datos --name jupyterlab_optimizacion_2 -p 8888:8888 -p 8787:8787 -d palmoreck/jupyterlab_optimizacion_2:3.0.0`
#
# password para jupyterlab: `qwerty`
#
# Detener el contenedor de docker:
#
# `docker stop jupyterlab_optimizacion_2`
#
# Documentación de la imagen de docker `palmoreck/jupyterlab_optimizacion_2:3.0.0` en [liga](https://github.com/palmoreck/dockerfiles/tree/master/jupyterlab/optimizacion_2).
#
# ```
# ---
# ```{admonition} Al final de esta nota el y la lectora:
# :class: tip
#
# *
#
# ```
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [default]
# language: python
# name: python2
# ---
# Based on what we saw during the slides, let's see if we can code up a single hidden layer neural network! If you're stuck on some of these parts, go back to the [linear regression](https://github.com/uclaacmai/tf-workshop-series-fall17/blob/master/week2-linear-regression/Intro%20to%20TF%20and%20Linear%20Regression.ipynb) and [logisitic regression](https://github.com/uclaacmai/tf-workshop-series-fall17/blob/master/week3-classification/Classification%20and%20Logistic%20Regression.ipynb) pieces of code.
# +
# Imports
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True) # reads in the MNIST dataset
# +
# TODO Define placeholders
# +
# TODO Define Hyperparameters
# +
# TODO Create our W1 weight and bias variables
# +
# TODO Create our W2 weight and bias variables
# +
# TODO Define the intermediate operations in our network (How can we compute h1 and yPred?)
# +
# TODO Define loss function and optimizer
# -
# functions that allow us to gauge accuracy of our model
correct_predictions = tf.equal(tf.argmax(yPred, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32))
# +
# TODO Define our global variable initializer
# +
# TODO Create our training loop
# -
# # More Exercises
# 1. Using different activation functions. Consult the Tensorflow documentation on `tanh` and `sigmoid`, and use that as the activation function instead of `relu`. Gauge the resulting changes in accuracy.
# 2. Varying the number of neurons - as mentioned, we have complete control over the number of neurons in our hidden layer. How does the testing accuracy change with a small number of neurons versus a large number of neurons? What about the generalization accuracy (with respect to the testing accuracy?)
# 3. Using different loss functions - we have discussed the cross entropy loss. Another common loss function used in neural networks is the MSE loss. Consult the Tensorflow documentation and implement the ```MSELoss()``` function.
# 4. Addition of another hidden layer - We can create a deeper neural network with additional hidden layers. Similar to how we created our original hidden layer, you will have to figure out the dimensions for the weights (and biases) by looking at the dimension of the previous layer, and deciding on the number of neurons you would like to use. Once you have decided this, you can simply insert another layer into the network with only a few lines of code:
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Numpy Tutorial
# <img src="https://imgs.xkcd.com/comics/machine_learning.png" width="40%" />
# ## Imports
import numpy as np
# ## Basics
A = np.array([1, 2, 3])
type(A)
A.shape
A * 2 + 3
B = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
B
B.shape
B[1, :]
B[:, 1]
B[1, 1]
B[1:, 1:]
# ## Helpful functions
B.sum()
np.zeros((5, 5))
np.ones((5, 5))
np.arange(1, 10)
B.reshape(-1)
np.c_[B, B]
np.r_[B, B]
# ## Broadcasting
A = np.array([[1, 0, 1], [0, 1, 0], [1, 0, 1]])
A == 0
A[A == 0] = 2
A
B = np.arange(1, 10)
B
B > 3
B < 7
(B > 3) & (B < 7)
B[(B > 3) & (B < 7)] = 42
B
# ## Additional Resources
#
# * [Numpy Tutorial](http://cs231n.github.io/python-numpy-tutorial/) (I used some parts of it while preparing this notebook)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# LSTM for closing bitcoin price with regression framing
# -
# %matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from pandas import read_csv
from keras.models import Sequential, load_model
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
import math
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
# +
# convert an array of values into a dataset matrix
# -
def create_dataset(dataset):
dataX, dataY = [], []
for i in range(len(dataset)-1):
dataX.append(dataset[i])
dataY.append(dataset[i + 1])
return np.asarray(dataX), np.asarray(dataY)
# +
# fix random seed for reproducibility
# -
np.random.seed(7)
# load the dataset
df = pd.read_csv('crypto.csv', index_col='date', parse_dates=True)
bitcoin_price = df[df['name']=='Bitcoin']
bitcoin_price.info()
# +
bitcoin_price = bitcoin_price.iloc[::-1]
df = bitcoin_price.drop(['ranknow','symbol','slug','name','open','high','low','volume','market','close_ratio','spread'], axis=1)
dataset = df.values
dataset = dataset.astype('float32')
# -
dataset
# LSTMs are sensitive to the scale of the input data. It can be a good practice to rescale the data to the range of 0-to-1, also called normalizing. We can easily normalize the dataset using the MinMaxScaler preprocessing class from the scikit-learn library
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
# The function takes one argument: the dataset, which is a NumPy array that we want to convert into a dataset. This function will create a dataset where X is the closing price of Bitcoin at a given time (t) and Y is the closing price of Bitcoin at the next time (t+1).
# +
#prepare the X and Y label
# -
X,y = create_dataset(dataset)
# +
#Take 80% of data as the training sample and 20% as testing sample
# -
trainX, testX, trainY, testY = train_test_split(X, y, test_size=0.20)
# The shape of the input data (X) for the LSTM network should be specifically in the form of [samples, time steps, features].<br>
# Currently, our data is in the form: [samples, features] and we are framing the problem as one time step for each sample. We can transform the prepared train and test input data into the expected structure using np.reshape() as follows:
# +
# reshape input to be [samples, time steps, features]
# -
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# We are now ready to design the LSTM model for our problem. The network has 1 input layer, a hidden layer with 4 LSTM blocks or neurons, and an output layer that makes a single value prediction. The LSTM blocks use sigmoid activation function by default. We train the network for 5 epochs and use a batch size of 1. Once trained, you can save the model using the model.save method. You can also use the load_model method to load a pre-trained model.
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(100, input_shape=(1, 1)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=5, batch_size=1, verbose=2)
# We can estimate the performance of the model on the train and test datasets once the model is fit. This will give us a point of comparison for new models.
#
#
# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
# invert predictions
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform(trainY)
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform(testY)
trainPredict
print("Price for last 5 days: ")
print(testPredict[-5:])
futurePredict = model.predict(np.asarray([[testPredict[-1]]]))
futurePredict = scaler.inverse_transform(futurePredict)
print("Bitcoin price for tomorrow: ", futurePredict)
mse = ((testPredict - testY) ** 2).mean(axis=None)
rmse = mse**0.5
plt.plot(testPredict[-100:])
plt.plot(testY[-100:])
plt.show()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: 'Python 3.9.6 64-bit (''enterprise'': conda)'
# name: python3
# ---
# # Model Selection: `model_1` vs `model_2a`
#
# * This notebook reproduces one of the Bayes factors found in figure 3 of the 12.5 year GWB search paper
# +
# %matplotlib inline
# %config InlineBackend.figure_format = 'retina'
# %load_ext autoreload
# %autoreload 2
import os, glob, json, pickle
import matplotlib.pyplot as plt
import numpy as np
from enterprise.pulsar import Pulsar
from enterprise_extensions import models, model_utils, hypermodel
import sys
sys.path.append("..")
from settings import fd_bins
# -
# ## Get par, tim, and noise files
psrlist = None # define a list of pulsar name strings that can be used to filter.
# set the data directory
datadir = '../data'
if not os.path.isdir(datadir):
datadir = '../../data'
print('datadir =', datadir)
# +
# for the entire pta
parfiles = sorted(glob.glob(datadir + '/par/*par'))
timfiles = sorted(glob.glob(datadir + '/tim/*tim'))
# filter
if psrlist is not None:
parfiles = [x for x in parfiles if x.split('/')[-1].split('.')[0] in psrlist]
timfiles = [x for x in timfiles if x.split('/')[-1].split('.')[0] in psrlist]
# Make sure you use the tempo2 parfile for J1713+0747!!
# ...filtering out the tempo parfile...
parfiles = [x for x in parfiles if 'J1713+0747_NANOGrav_12yv3.gls.par' not in x]
# +
# check for file and load pickle if it exists:
pickle_loc = datadir + '/psrs.pkl'
if os.path.exists(pickle_loc):
with open(pickle_loc, 'rb') as f:
psrs = pickle.load(f)
# else: load them in slowly:
else:
psrs = []
ephemeris = 'DE438'
for p, t in zip(parfiles, timfiles):
psr = Pulsar(p, t, ephem=ephemeris)
psrs.append(psr)
# +
## Get parameter noise dictionary
noise_ng12 = datadir + '/channelized_12p5yr_v3_full_noisedict.json'
params = {}
with open(noise_ng12, 'r') as fp:
params.update(json.load(fp))
# -
# * We want to be able to compute the posterior odds ratio for a signal in the data. This can be done using the hypermodel class, where we choose between a `model_2a` with a common (but uncorrelated) red process in the pulsars, and `model_1` with only intrinsic red noise in the model.
#
# * We typically perform detection-type analyses with uniform-in-log priors on all amplitude parameters for low-frequency processes. This is implemented below with `upper_limit` equal to `False`.
# ## Setup dictionary of PTA models
# * `model_1` consists of a PTA with only intrinsic red noise
# * `model_2a` includes a common red process where (for this analysis) we set the spectral index to 13/3
# * We also change `n_gwbfreqs` to only include the lowest 5 frequencies to match closely with the 12.5 year SGWB search
# * There are other model functions built into `enterprise_extensions`.
# * Check out the documentation of each function in the `models.py` file of `enterprise_extensions` for more information.
# +
nmodels = 2
mod_index = np.arange(nmodels)
# Make dictionary of PTAs.
pta = dict.fromkeys(mod_index)
pta[0] = models.model_1(psrs, psd='powerlaw', noisedict=params)
pta[1] = models.model_2a(psrs, psd='powerlaw', noisedict=params, n_gwbfreqs=5, gamma_common=13/3)
# -
# * In setting up the `HyperModel` in the next cell, we set weights to make the models sample more evenly.
# * `log_weights` is a list with the same length as the models, and each entry is added to the corresponding log-likelihood
# * To undo the weights, we will divide each fraction by the exponential of the `log_weights`
super_model = hypermodel.HyperModel(pta, log_weights=[10, 0])
# ## Sample
outDir = '../../chains/ms_12a_chains'
sampler = super_model.setup_sampler(resume=True, outdir=outDir, sample_nmodel=True,)
# sampler for N steps
N = int(5e6) # 5e6 is a good number for a real analysis
x0 = super_model.initial_sample()
# +
# sample
# sampler.sample(x0, N, SCAMweight=30, AMweight=15, DEweight=50, )
# +
# uncomment this line if you sampled yourself:
# chain = np.loadtxt(outDir + '/chain_1.txt')
# this line will load the chains that we have provided:
chain = np.load(outDir + '/chain_1.npz')['arr_0']
burn = int(0.1 * chain.shape[0])
pars = np.loadtxt(outDir + '/pars.txt', dtype=np.unicode_)
ind_model = list(pars).index('nmodel')
# -
# Make trace-plot to diagnose sampling
# We want this plot to look more like a fuzzy caterpillar than a skinny worm
plt.figure(figsize=(12, 5))
plt.plot(chain[burn:, ind_model])
plt.xlabel('Sample Number')
plt.ylabel('nmodel')
plt.title('Trace Plot')
plt.grid(b=True)
plt.show()
# +
# Plot histgram for GW amplitude
chain_burn = chain[burn:,:]
ind_model = list(pars).index('nmodel')
ind_gwamp = list(pars).index('gw_log10_A')
# -
# Plot a histogram of the marginalized posterior distribution for ind_model > 0.5 (includes common red process)
bins = fd_bins(chain_burn[chain_burn[:, ind_model] > 0.5, ind_gwamp], logAmin=-18, logAmax=-12) # let FD rule decide bins (in ../settings.py)
plt.figure(figsize=(12, 5))
plt.title('Histogram')
plt.hist(chain_burn[chain_burn[:, ind_model] > 0.5, ind_gwamp], bins=bins, histtype='stepfilled',
lw=2, color='C0', alpha=0.5, density=True)
plt.xlabel('log10_A_gw')
plt.show()
# Plot histogram for GWB model selection
# This will tell us how much we have sampled for each model
plt.figure(figsize=(12, 5))
plt.title('Histogram')
plt.hist(chain_burn[:, ind_model], bins=40, histtype='stepfilled',
lw=2, color='C0', alpha=0.5, density=True)
plt.xlabel('log10_A_gw')
plt.ylabel('PDF')
plt.show()
# ### Hypermodel
# * The `HyperModel` has approximately equivalent numbers of samples in each model, but the first model is strongly weighted.
# * This implies that the second model is **strongly** favored.
# * To undo the `log_weights` from earlier, we multiply the posterior odds ratio by $e^{10}$.
#
# ### Posterior odds ratio
#
# * This gives the posterior odds ratio between a model with intrinsic red noise only (`model_1`), and a common (but uncorrelated) red process between pulsars (`model_2a`).
# * This will tell us if the pulsars prefer a common red noise term over no common term, but it will not tell us if this is the GWB.
# * We will return to this in the next section to compare between a common (uncorrelated) red noise term and a red noise term with Hellings and Downs (HD) correlations.
# * HD correlations would indicate that the common signal is a gravitational wave background.
# * The posterior odds ratio here indicates that there is **strong** evidence for a common red noise signal among pulsars
# The first number is the posterior odds ratio (POR) and the second number is the uncertainty on the POR
por, unc = model_utils.odds_ratio(chain_burn[:, ind_model], models=[0,1])
print(por, unc)
log10por = np.log10(por*np.exp(10)) # we multiply by exp(10) to undo the log_weight of 10
print(log10por)
# * The posterior odds ratio is nearly what was published in the 12.5 year stochastic GWB search where a value of 4.5 was found
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# Lab Assignment 4
# Q.1 A website requires the users to input username and password to register. Write a program to check the validity of password input by users. Following are the criteria for checking the password:
#
# At least 1 letter between [a-z]
# At least 1 number between [0-9]
# At least 1 letter between [A-Z]
# At least 1 character from [$#@]
# Minimum length of transaction password: 6
# Maximum length of transaction password: 12 Your program should accept a sequence of comma separated passwords and will check them according to the above criteria. Passwords that match the criteria are to be printed, each separated by a comma. Example If the following passwords are given as input to the program: ABd1234@1,a F1#,2w3E*,2We3345 Then, the output of the program should be: ABd1234@1 be correct password Hints: In case of input data being supplied to the question, it should be assumed to be a console input.
# +
beg,lap,hass,multi = 0, 0, 0, 0
UserName=input("Enter Your Username :")
Password= input("Enter Your Password :")
if (len(Password) >= 8):
for i in Password:
if (i.islower()): # performing on lowercase alphabets
beg+=1
if (i.isupper()): # performing on uppercase alphabets
lap+=1
if (i.isdigit()): # performing on digits
hass+=1
# counting the mentioned special characters
if(i=='@'or i=='$' or i=='_'):
multi+=1
if (beg>=1 and lap>=1 and multi>=1 and hass>=1 and beg+lap+multi+hass==len(Password)):
print("Valid Password")
else:
print("Invalid Password")
# -
# Q 2 You are required to write a program to sort the (name, age, height) tuples by ascending order where name is string, age and height are numbers. The tuples are input by console. The sort criteria is: 1: Sort based on name; 2: Then sort based on age; 3: Then sort by score. The priority is that name > age > score. If the following tuples are given as input to the program: Tom,19,80 John,20,90 Jony,17,91 Jony,17,93 Json,21,85 Then, the output of the program should be: [('John', '20', '90'), ('Jony', '17', '91'), ('Jony', '17', '93'), ('Json', '21', '85'), ('Tom', '19', '80')]
#
# Hints: In case of input data being supplied to the question, it should be assumed to be a console input. We use itemgetter to enable multiple sort keys
from operator import itemgetter
UserData = [] # empty list to append sorted items
print("Please enter the user data in order of first and last name, age and height separated by commas. ")
while True:
InputData = input()
if not InputData:
break
UserData.append(tuple(InputData.split(","))) # converting to tuple
print("Your result:")
print(sorted(UserData, key=itemgetter(0,1,2))) # use of itemgetter
# Q.3 Write a program to compute the frequency of the words from the input. The output should output after sorting the key alphanumerically.
# Suppose the following input is supplied to the program:
# New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.
# Then, the output should be:
# 2:2
# 3.:1
# 3?:1
# New:1
# Python:5
# Read:1
# and:1
# between:1
# choosing:1
# or:2
# to:1
#
# Hints
# In case of input data being supplied to the question, it should be assumed to be a console input.
# +
print("Enter Your String:")
MyLst = input().split()
word = sorted(set(MyLst)) # split words are stored and sorted as a set
for i in word:
print("{0}:{1}".format(i,MyLst.count(i)))
# -
# Q.4 Please write a program which accepts a string from console and print the characters that have even indexes.
#
# Example:
# If the following string is given as input to the program:
#
# H1e2l3l4o5w6o7r8l9d
#
# Then, the output of the program should be:
#
# Helloworld
#
# Hints:
# Use list[::2] to iterate a list by step 2.
string = input("Enter your string: ")
NewString = '' #empty string
for i in range(len(string)):
if i % 2 == 0: #getting even indexed element
NewString+= string[i]
print("program generated string:",NewString)
# Q 5 With a given list [12,24,35,24,88,120,155,88,120,155],
# write a program to print this list after removing all duplicate values with original order reserved.
#
# Hints:
# Use set() to store a number of values without duplicate.
#
# +
mylst = [12,24,35,24,88,120,155,88,120,155] #given list
DupItems = set() # setting elments
UniqItems = []
for x in mylst:
if x not in DupItems:
UniqItems.append(x) # appending element new one
DupItems.add(x)
print(UniqItems)
# -
# Q 6 Given a string, find a substring based on the following conditions:
#
# The substring must be the longest one of all the possible substring in the given string.
# There must not be any repeating characters in the substring.
# If there is more than one substring satisfying the above two conditions, then print the substring which occurs first.
# If there is no substring satisfying all the aforementioned conditions then print -1.
# +
print("Enter yourt string") #taking input from user
MyString=input()
MySubString=""
Maxchar=0
for i in range(len(MyString)-1):
k=i
for j in range(i+1,len(MyString)):
if MyString[j] not in MyString[i:j]:
k+=1
else:
break
if len(MyString[i:k+1])>=Maxchar:
Maxchar=len(MyString[i:k+1])
MySubString=MyString[i:k+1]
print(MySubString)
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
from selenium import webdriver
from bs4 import BeautifulSoup
import pandas as pd
import re
import csv
import requests
import os
driver=webdriver.Chrome(executable_path="D:\chromedriver_win32\chromedriver.exe")
driver.get("https://downtowndallas.com/experience/stay/")
#A list to hold the URLs of Hotel pages
listhotels = []
maincontent = driver.page_source
soupmain = BeautifulSoup(maincontent)
#getting the links of hotels pages and storing them in the list
for hotels in soupmain.find_all(attrs='place-square__btn'):
link = hotels.get('href')
if link not in listhotels:
listhotels.append(link)
driver.close()
download_img=[]
for link in listhotels:
results = []
driver = webdriver.Chrome(executable_path='D:\chromedriver_win32\chromedriver.exe')
driver.get(link)
content = driver.page_source
soup = BeautifulSoup(content)
name = soup.h1.string
if name not in results:
results.append(name)
for element in soup.find_all(attrs='place-info-address'):
link = element.a
txt = link.get_text("|", strip=True)
if txt not in results:
results.append(txt)
image = soup.find(attrs='place-info-image')
img = image.img
image_link = img.get("src")
#getting the URLs for images
if image_link not in results:
results.append(image_link)
download_img.append(image_link)
#storing details in csv file
with open("details.csv", "a") as fp:
wr = csv.writer(fp, dialect='excel')
wr.writerow(results)
with open("img.csv", "a") as fp:
wr = csv.writer(fp, dialect='excel')
wr.writerow(download_img)
driver.close()
# -
import urllib.request
import csv
headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:23.0) Gecko/20100101 Firefox/23.0'}
with open('img.csv', 'r') as f:
i=0
reader = csv.reader(f)
for row in reader:
req = urllib.request.Request(url=row[1], headers=headers)
img = urllib.request.urlopen(req).read()
with open(f'hotel{i}.jpg', 'wb') as f:
f.write(img)
i+=1
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import pandas as pd
from sklearn.metrics import mean_squared_error
# +
## diccionaries
catalogo = pd.read_excel("../BaseDatos.xlsx", sheet_name="Catalogo")
catalogo = catalogo[["Articulo", "Precio", "Costo", "TiempoVidaAnaquel", "Tamaño_Surtido"]].dropna()
for i in catalogo.columns:
catalogo.rename(columns={i: i.lower().replace("ñ", "n")}, inplace=True)
catalogo.rename(columns={"articulo":"sku"}, inplace=True)
catalogo["ganancia_uni"] = catalogo["precio"]-catalogo["costo"]
catalogo["pro_ganacia"] = catalogo["ganancia_uni"]/catalogo["costo"]
catalogo = catalogo[["sku", "precio", "costo"]]
catalogo.rename(columns={"sku":"SKU"}, inplace=True)
catalogo.head()
# +
vent_col = ['SKU', 'LOC', 'w_1', 'w_2', 'w_3', 'w_4', 'w_5',
'w_6', 'w_7', 'w_8', 'w_9', 'w_10', 'w_11', 'w_12' ]
ventas = pd.read_csv("../data/ventas_sku_loc_week.csv")
ventas["week"] = ventas.groupby(["SKU","LOC"]).cumcount()+1
ventas["week"] = ventas["week"].apply(lambda x: "w_"+str(x))
ventas_pivot = ventas.pivot_table(columns="week",values="UNI", index=["SKU", "LOC"]).reset_index()
ventas_pivot= ventas_pivot[vent_col]
# -
ventas_pivot["pre_w_11"] = ventas_pivot[["w_9", "w_10"]].apply(lambda x: np.round(x.mean())+1, axis=1)
ventas_pivot["pre_w_12"] = ventas_pivot[["w_9", "w_10"]].apply(lambda x: np.round(x.mean())+1, axis=1)
ventas_pivot
ventas_ganancias= pd.merge(ventas_pivot, catalogo, on="SKU", how="left")
ventas_ganancias["ganacias"] = ventas_ganancias[["precio", "costo"]].apply(lambda x: x[0]-x[1], axis=1)
ventas_ganancias.head()
def mse(actual, pred, w):
actual, pred = np.array(actual), np.array(pred)
return np.square(w*np.subtract(actual,pred)).mean()
ventas_ganancias["error_pon_w11"] = ventas_ganancias[["w_11", "pre_w_11", "costo"]].apply(lambda x: (x[0]-x[1])*x[2], axis=1)
ventas_ganancias["error_pon_w12"] = ventas_ganancias[["w_12", "pre_w_12", "costo"]].apply(lambda x: (x[0]-x[1])*x[2], axis=1)
ventas_ganancias["error_pon_w11"].hist(bins=30)
ventas_ganancias["error_pon_w12"].hist(bins=30)
ventas_ganancias.sort_values("error_pon_w12")
# ### MSE para las últimas dos semanas
mse(ventas_ganancias.w_11, ventas_ganancias.pre_w_11, ventas_ganancias.ganacias)
mse(ventas_ganancias.w_12, ventas_ganancias.pre_w_12, ventas_ganancias.ganacias)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Orientation matched filters response
import numpy as np
import matplotlib.pyplot as plt
import scipy.ndimage as image
import skimage.io as io
import seaborn as sns
import pandas as pd
def orientedGaussKernel(sigma=1.0,ratio=0.25, angle=0.0) :
angle = np.pi*angle/180.0
size = np.ceil(sigma * 3).astype(int)
x,y = np.meshgrid(np.linspace(-size,size,2*size+1),np.linspace(-size,size,2*size+1))
xr = x*np.cos(angle) + y*np.sin(angle)
yr = - x*np.sin(angle) + y*np.cos(angle)
k=np.exp(-((xr**2)/(2*sigma**2) + (yr**2)/(2*(ratio*sigma)**2)))
k=k/k.sum()
return k
N=11
fig, axes = plt.subplots(1,N,figsize=(15,4))
for ax,angle in zip(axes,np.linspace(0,180,N)) :
ax.imshow(orientedGaussKernel(sigma=2,ratio=0.25,angle=angle))
def matchedFilterResponse(img,sigma=2,ratio=0.25, dirs=11) :
angles = np.linspace(0,180-180/dirs,dirs)
res=np.zeros(img.shape)
for angle in angles :
fimg=image.convolve(img,orientedGaussKernel(sigma=sigma,ratio=ratio,angle=angle))
res=np.maximum(res,fimg)
return res
img = io.imread('cellimage.tif')
plt.imshow(img)
mfr = matchedFilterResponse(img[:,:,0],sigma=3,ratio=0.2, dirs=11)
fig, ((ax1,ax2),(ax3,ax4)) =plt.subplots(2,2,figsize=(12,10))
ax1.imshow(img[:,:,0])
ax2.imshow(mfr)
ax3.hist(img[:,:,0].ravel(),bins=256);
ax3.set_yscale('log')
ax4.hist(mfr.ravel(),bins=256);
ax4.set_yscale('log')
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Tuples
# -> A tuple is similar to list
#
# -> The diffence between the two is that we can't change the elements of tuple once it is assigned whereas in the list, elements can be changed
# # Tuple creation
# +
#empty tuple
t = ()
#tuple having integers
t = (1, 2, 3)
print(t)
#tuple with mixed datatypes
t = (1, 'raju', 28, 'abc')
print(t)
#nested tuple
t = (1, (2, 3, 4), [1, 'raju', 28, 'abc'])
print(t)
# -
#only parenthesis is not enough
t = ('satish')
type(t)
#need a comma at the end
t = ('satish',)
type(t)
# +
#parenthesis is optional
t = "satish",
print(type(t))
print(t)
# -
# # Accessing Elements in Tuple
# +
t = ('satish', 'murali', 'naveen', 'srinu', 'brahma')
print(t[1])
# -
#negative index
print(t[-1]) #print last element in a tuple
# +
#nested tuple
t = ('ABC', ('satish', 'naveen', 'srinu'))
print(t[1])
# -
print(t[1][2])
# +
#Slicing
t = (1, 2, 3, 4, 5, 6)
print(t[1:4])
#print elements from starting to 2nd last elements
print(t[:-2])
#print elements from starting to end
print(t[:])
# -
# # Changing a Tuple
# #unlike lists, tuples are immutable
# #This means that elements of a tuple cannot be changed once it has been assigned. But, if the element is itself a mutable datatype like list, its nested items can be changed.
# +
#creating tuple
t = (1, 2, 3, 4, [5, 6, 7])
t[2] = 'x' #will get TypeError
# -
t[4][1] = 'satish'
print(t)
# +
#concatinating tuples
t = (1, 2, 3) + (4, 5, 6)
print(t)
# -
#repeat the elements in a tuple for a given number of times using the * operator.
t = (('satish', ) * 4)
print(t)
# # Tuple Deletion
# +
#we cannot change the elements in a tuple.
# That also means we cannot delete or remove items from a tuple.
#delete entire tuple using del keyword
t = (1, 2, 3, 4, 5, 6)
#delete entire tuple
del t
# -
# # Tuple Count
# +
t = (1, 2, 3, 1, 3, 3, 4, 1)
#get the frequency of particular element appears in a tuple
t.count(1)
# -
# # Tuple Index
# +
t = (1, 2, 3, 1, 3, 3, 4, 1)
print(t.index(3)) #return index of the first element is equal to 3
#print index of the 1
# -
# # Tuple Memebership
# +
#test if an item exists in a tuple or not, using the keyword in.
t = (1, 2, 3, 4, 5, 6)
print(1 in t)
# -
print(7 in t)
# # Built in Functions
# # Tuple Length
t = (1, 2, 3, 4, 5, 6)
print(len(t))
# # Tuple Sort
# +
t = (4, 5, 1, 2, 3)
new_t = sorted(t)
print(new_t) #Take elements in the tuple and return a new sorted list
#(does not sort the tuple itself).
# +
#get the largest element in a tuple
t = (2, 5, 1, 6, 9)
print(max(t))
# -
#get the smallest element in a tuple
print(min(t))
#get sum of elments in the tuple
print(sum(t))
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Droplet Evaporation
import numpy as np
import matplotlib.pyplot as plt
# +
# Ethyl Acetate
#time_in_sec = np.array([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,105,110])
#diameter = np.array([2.79,2.697,2.573,2.542,2.573,2.48,2.449,2.449,2.387,2.356,2.263,2.232,2.201,2.139,1.82,1.426,1.178,1.085,0.992,0.496,0.403,0.372,0.11])
# Gasoline
#time_in_min = np.array([0,15,30,45,60,75,90,105,120,135,150,165,180,210,235,250,265])
#diameter = np.array([2,1.85,1.82,1.8,1.77,1.74,1.72,1.68,1.57,1.3,1.166,1.091,0.94,0.81,0.74,0.66,0.59])
# -
# # Ethyl Acetate
time_in_sec = np.array([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,105,110])
diameter = np.array([2.79,2.697,2.573,2.542,2.573,2.48,2.449,2.449,2.387,2.356,2.263,2.232,2.201,2.139,1.82,1.426,1.178,1.085,0.992,0.496,0.403,0.372,0.11])
# +
x = time_in_sec.tolist()
y = diameter.tolist()
polynomial_coeff_1=np.polyfit(x,y,1)
polynomial_coeff_2=np.polyfit(x,y,2)
polynomial_coeff_3=np.polyfit(x,y,3)
xnew=np.linspace(0,110 ,100)
ynew_1=np.poly1d(polynomial_coeff_1)
ynew_2=np.poly1d(polynomial_coeff_2)
ynew_3=np.poly1d(polynomial_coeff_3)
plt.plot(x,y,'o')
plt.plot(xnew,ynew_1(xnew))
plt.plot(xnew,ynew_2(xnew))
plt.plot(xnew,ynew_3(xnew))
print(ynew_1)
print(ynew_2)
print(ynew_3)
plt.title("Diameter vs Time(s)")
plt.xlabel("Time(s)")
plt.ylabel("Diameter")
plt.show()
# Coeficients
# LINEAR : -0.02386 x + 3.139
# QUADRATIC : -0.0002702 x^2 + 0.005868 x + 2.619
# CUBIC : -4.771e-07 x^3 - 0.0001915 x^2 + 0.002481 x + 2.646
#
# Using Desmos to find the roots of the best fit polynomials
# Root of linear fit = 131.559
# Root of quadratic fit = 109.908
# Root of cubic fit = 109.414
# -
# Calculating time taken for vaporization for different diameters.
diameter = np.array([2.79,2.697,2.573,2.542,2.573,2.48,2.449,2.449,2.387,2.356,2.263,2.232,2.201,2.139,1.82,1.426,1.178,1.085,0.992,0.496,0.403,0.372,0.11])
time_in_sec = np.array([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,105,110])
t_vap = time_in_sec
t_vap = t_vap*0
t_vap = t_vap + 109.908
t_vap = t_vap - time_in_sec
print(t_vap.tolist())
# # Ethyl Acetate - After finding Vaporization Time Data
# Finding C and n for d-square law
#initial_diameter = np.array([2.79,2.697,2.573,2.542,2.573,2.48,2.449,2.449,2.387,2.356,2.263,2.232,2.201,2.139,1.82,1.426,1.178,1.085,0.992,0.496,0.403,0.372,0.11])
#vap_time = np.array([109.908, 104.908, 99.908, 94.908, 89.908, 84.908, 79.908, 74.908, 69.908, 64.908, 59.908, 54.908, 49.908, 44.908, 39.908, 34.908, 29.908, 24.908, 19.908, 14.908000000000001, 9.908000000000001, 4.908000000000001, -0.09199999999999875])
initial_diameter = np.array([2.79,2.697,2.573,2.542,2.573,2.48,2.449,2.449,2.387,2.356,2.263,2.232,2.201,2.139,1.82,1.426,1.178,1.085,0.992,0.496,0.403,0.372])
vap_time = np.array([109.908, 104.908, 99.908, 94.908, 89.908, 84.908, 79.908, 74.908, 69.908, 64.908, 59.908, 54.908, 49.908, 44.908, 39.908, 34.908, 29.908, 24.908, 19.908, 14.908000000000001, 9.908000000000001, 4.908000000000001])
def d_square_law(x, C, n):
y = C/(x**n)
return y
parameters = optimize.curve_fit(d_square_law, xdata = initial_diameter, ydata = vap_time)[0]
print(parameters)
C = parameters[0]
n = parameters[1]
# +
C = 11.6827828
n = -2.13925924
x = vap_time.tolist()
y = initial_diameter.tolist()
ynew=np.linspace(0,3 ,100)
xnew=[]
for item in ynew:
v1 = C/(item**n)
xnew.append(v1)
plt.plot(x,y,'o')
plt.plot(xnew,ynew)
plt.title("Initial Diameter vs Vaporization Time(s)")
plt.xlabel("Vaporization Time(s)")
plt.ylabel("Initial Diameter")
plt.show()
# -
# # Gasoline
time_in_min = np.array([0,15,30,45,60,75,90,105,120,135,150,165,180,210,235,250,265])
diameter = np.array([2,1.85,1.82,1.8,1.77,1.74,1.72,1.68,1.57,1.3,1.166,1.091,0.94,0.81,0.74,0.66,0.59])
# +
x = time_in_min.tolist()
y = diameter.tolist()
polynomial_coeff_1=np.polyfit(x,y,1)
polynomial_coeff_2=np.polyfit(x,y,2)
polynomial_coeff_3=np.polyfit(x,y,3)
xnew=np.linspace(0,300 ,100)
ynew_1=np.poly1d(polynomial_coeff_1)
ynew_2=np.poly1d(polynomial_coeff_2)
ynew_3=np.poly1d(polynomial_coeff_3)
plt.plot(x,y,'o')
plt.plot(xnew,ynew_1(xnew))
plt.plot(xnew,ynew_2(xnew))
plt.plot(xnew,ynew_3(xnew))
print(ynew_1)
print(ynew_2)
print(ynew_3)
plt.title("Diameter vs Time(min)")
plt.xlabel("Time(min)")
plt.ylabel("Diameter")
plt.show()
# Coeficients
# LINEAR : -0.005637 x + 2.074
# QUADRATIC : -6.67e-06 x^2 - 0.003865 x + 2
# CUBIC : 1.481e-07 x^3 - 6.531e-05 x^2 + 0.00207 x + 1.891
#
# Using Desmos to find the roots of the best fit polynomials
# Root of linear fit = 367.926
# Root of quadratic fit = 329.781
# Root of cubic fit = No Positive Root
# -
# Calculating time taken for vaporization for different diameters.
time_in_min = np.array([0,15,30,45,60,75,90,105,120,135,150,165,180,210,235,250,265])
diameter = np.array([2,1.85,1.82,1.8,1.77,1.74,1.72,1.68,1.57,1.3,1.166,1.091,0.94,0.81,0.74,0.66,0.59])
t_vap = time_in_min
t_vap = t_vap*0
t_vap = t_vap + 329.781
t_vap = t_vap - time_in_min
print(t_vap.tolist())
# # Gasoline - After finding Vaporization Time Data
initial_diameter_g = np.array([2,1.85,1.82,1.8,1.77,1.74,1.72,1.68,1.57,1.3,1.166,1.091,0.94,0.81,0.74,0.66,0.59])
vap_time_g = np.array([329.781, 314.781, 299.781, 284.781, 269.781, 254.781, 239.781, 224.781, 209.781, 194.781, 179.781, 164.781, 149.781, 119.781, 94.781, 79.781, 64.781])
def d_square_law(x, C, n):
y = C/(x**n)
return y
parameters_g = optimize.curve_fit(d_square_law, xdata = initial_diameter_g, ydata = vap_time_g)[0]
print(parameters_g)
C_g = parameters_g[0]
n_g = parameters_g[1]
# +
C_g = 140.10666889
n_g = -1.1686059
x_g = vap_time_g.tolist()
y_g = initial_diameter_g.tolist()
ynew_g=np.linspace(0,2.2 ,100)
xnew_g=[]
for item in ynew_g:
v1 = C_g/(item**n_g)
xnew_g.append(v1)
print(ynew_g)
print(xnew_g)
plt.plot(x_g,y_g,'o')
plt.plot(xnew_g,ynew_g)
plt.title("Initial Diameter vs Vaporization Time(min)")
plt.xlabel("Vaporization Time(min)")
plt.ylabel("Initial Diameter")
plt.show()
# -
# # Optimization Methods (IGNORE)
# +
import numpy as np
from scipy import optimize
import matplotlib.pyplot as plt
plt.style.use('seaborn-poster')
# -
time_in_sec = np.array([5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,105,110])
diameter = np.array([2.697,2.573,2.542,2.573,2.48,2.449,2.449,2.387,2.356,2.263,2.232,2.201,2.139,1.82,1.426,1.178,1.085,0.992,0.496,0.403,0.372,0.11])
# +
def func(x, a, b):
y = a/(x**b)
return y
parameters = optimize.curve_fit(func, xdata = time_in_sec, ydata = diameter)[0]
print(parameters)
C = parameters[0]
n = parameters[1]
# -
plt.plot(time_in_sec,diameter,'o',label='data')
y_new = []
for val in time_in_sec:
v1 = C/(val**n)
y_new.append(v1)
plt.plot(time_in_sec,y_new,'-',label='fit')
# +
log_time = np.log(time_in_min)
log_d = np.log(diameter)
print(log_d)
print(log_time)
x = log_time.tolist()
y = log_d.tolist()
polynomial_coeff=np.polyfit(x,y,1)
xnew=np.linspace(2.5,6,100)
ynew=np.poly1d(polynomial_coeff)
plt.plot(xnew,ynew(xnew),x,y,'o')
print(ynew)
plt.title("log(diameter) vs log(Time(s))")
plt.xlabel("log(Time(s))")
plt.ylabel("log(diameter)")
plt.show()
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Quantum Concepts: Open quantum systems
# $$
# \newcommand{\ket}[1]{\left|#1\right\rangle}
# \newcommand{\bra}[1]{\left\langle#1\right|}
# \newcommand{\Tr}[0]{\operatorname{Tr}}
# $$
# ## Introduction
# Often in quantum computing, we'll talk about quantum systems that are very well isolated from their environments, such that no noise affects the qubits in such systems. We say that quantum systems that are isolated in this way are _closed quantum systems_.
#
# By contrast, a device that is subject to some amount of noise from its environment is an _open quantum system_. In this notebook, we'll cover some of the basics on representing the states of open quantum systems, and how quantum operations affect the states of open systems.
# ## Preamble
# We start by importing the [QuTiP](https://qutip.org/) library, a popular Python library for manipulating states and processes of closed and open quantum systems.
import qutip as qt
import numpy as np
import matplotlib.pyplot as plt
# We next import Q# ↔ Python interoperability and enable the preview noisy simulation feature.
import qsharp
import qsharp.experimental
qsharp.experimental.enable_noisy_simulation()
# We'll also open a few Q# namespaces that will be helpful to us in the rest of the notebook.
# +
# %%qsharp
open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.Random;
# -
# ## Revisiting quantum states
# Before proceeding to discuss representing open quantum systems, it's helpful to quickly revisit representations of closed quantum systems. In particular, we can represent the state of an $n$-qubit register as a vector of $2^n$ complex numbers. For example, the state of a single qubit can be written as a vector of the form
# $$
# \begin{aligned}
# \ket{\psi} = \alpha \ket{0} + \beta \ket{1} = \left( \begin{matrix}
# \alpha \\ \beta
# \end{matrix} \right)
# \end{aligned}
# $$
# for complex numbers $\alpha$ and $\beta$ such that $|\alpha|^2 + |\beta|^2 = 1$.
#
# In Q#, we can ask the default simulator to dump the state that it uses to simulate quantum programs, getting back a description of that state as a vector of this form.
# %%qsharp
operation DumpPlus() : Unit {
use q = Qubit();
within {
H(q);
} apply {
DumpMachine();
}
}
DumpPlus.simulate()
# The above diagnostic tells us that at the point when `DumpMachine` is called, the state of `q` is given by the vector $\ket{+} \mathrel{:=} (\ket{0} + \ket{1}) / \sqrt{2} \approx 0.7071 \ket{0} + 0.7071 \ket{1}$.
#
# We can also write this state in QuTiP notation, using `qt.basis(2, i)` to represent $\ket{i}$ on a single qubit:
ket0 = qt.basis(2, 0)
ket1 = qt.basis(2, 1)
ket_plus = (1 / np.sqrt(2)) * (ket0 + ket1)
ket_plus
# When we measure a qubit in the $\ket{+}$ state in the $Z$-basis, we get `Zero` and `One` with equal probability:
# +
# %%qsharp
operation SampleRandomBit() : Result {
use q = Qubit();
H(q);
return MResetZ(q);
}
# -
sum(SampleRandomBit.simulate() for _ in range(100))
# Importantly, though, the $\ket{+}$ state is not inherently random — we can determinstically return to the $\ket{0}$ state by applying another `H` operation:
# +
# %%qsharp
operation ApplyHTwiceAndMeasure() : Result {
use q = Qubit();
H(q);
H(q);
return MResetZ(q);
}
# -
sum(ApplyHTwiceAndMeasure.simulate() for _ in range(100))
# ## Preparing random states
# As opposed to preparing $\ket{+}$ and measuring, we could also consider flipping a coin classically, and using the outcome to prepare either the $\ket{0}$ or $\ket{1}$ state.
#
# 
# +
# %%qsharp
operation PrepareAndMeasureRandomState() : Result {
use q = Qubit();
if DrawRandomBool(0.5) {
X(q);
}
return MResetZ(q);
}
# -
# Doing so, we get the same 50/50 outcomes that we saw before:
sum(PrepareAndMeasureRandomState.simulate() for _ in range(100))
# This time, however, when we apply `H` again, we don't get back to a determinstic outcome:
# +
# %%qsharp
operation ApplyHToRandomStateAndMeasure() : Result {
use q = Qubit();
if DrawRandomBool(0.5) {
X(q);
}
H(q); // ← Doesn't get us back to |0⟩!
return MResetZ(q);
}
# -
sum(ApplyHToRandomStateAndMeasure.simulate() for _ in range(100))
# As it turns out, there is no single vector that we can use to represent the state prepared by `ApplyHToRandomStateAndMeasure` unless we know the outcome of the random coin flip (`DrawRandomBool(0.5)`) in our description. If we don't know the outcome of the coin flip, we have an _ensemble_ of state vectors,
# $$
# \begin{aligned}
# \rho =
# \left\{
# \ket{0} \text{ with probability 50%}, \quad
# \ket{1} \text{ with probability 50%}
# \right\}.
# \end{aligned}
# $$
# Just as with the quantum states that we're used to, we can predict measurements of such ensembles using Born's rule,
# $$
# \begin{aligned}
# \Pr(\phi | \psi) & = \left|\left\langle \phi | \psi \right\rangle\right|^2 \\
# & = \left\langle \phi | \psi \right\rangle \left\langle \psi | \phi \right\rangle.
# \end{aligned}
# $$
# The trick here is to average over the different state vectors that could be prepared by our operation:
# $$
# \begin{aligned}
# \Pr(\phi | \rho)
# & = \mathbb{E}_{\psi \sim \rho} \left[
# \Pr(\phi | \psi)
# \right] \\
# & = \mathbb{E}_{\psi \sim \rho} \left [
# \left\langle \phi | \psi \right\rangle \left\langle \psi | \phi \right\rangle
# \right] \\
# & = \sum_i \Pr(\psi_i) \left\langle \phi | \psi_i \right\rangle \left\langle \psi_i | \phi \right\rangle \\
# & = \left\langle
# \phi \Bigg| \left(
# \sum_i \Pr(\psi_i) \ket{\psi_i} \bra{\psi_i}
# \right) \Bigg| \phi
# \right\rangle.
# \end{aligned}
# $$
# Factoring out $\bra{\phi}$ and $\ket{\phi}$ in the last step gives us a neat new way of writing out ensembles of state vectors as matrices called _density operators_. For example, the ensemble $\rho$ above can also be written out as a density operator,
# $$
# \begin{aligned}
# \rho & = \sum_i \Pr(\psi_i) \ket{\psi_i} \bra{\psi_i} \\
# & = \frac12 \ket{0} \bra{0} + \frac12 \ket{1} \bra{1} \\
# & = \frac12 \left( \begin{matrix}
# 1 & 0 \\ 0 & 1
# \end{matrix} \right).
# \end{aligned}
# $$
# Using density operators, we can write both ensembles of states, as well as the kinds of closed system states that we're used to as _projectors_ on to those state vectors. For example, the $\ket{+}$ state from above can be written as the density operator
# $$
# \begin{aligned}
# \ket{+}\bra{+} =
# \frac12 \left( \begin{matrix}
# 1 & 1 \\ 1 & 1
# \end{matrix} \right).
# \end{aligned}
# $$
# That is, even though both `SampleRandomBit` and `PrepareAndMeasureRandomState` both prepare density operators with the same diagonal elements (and thus have the same measurement probabilies in the $Z$-basis), the two density operators have different off-diagonal elements. We say that density operators in general represent _mixed states_, and that states that can be written as $\ket{\psi}\bra{\psi}$ for some state vector $\ket{\psi}$ (e.g.: $\ket{+}\bra{+}$) are _pure states_.
#
# To tell how close a given density operator $\rho$ is to being pure, we can look at the trace (that is the sum of the diagonal elements) of $\rho^2$:
rho_mixed = (ket0 * ket0.dag() + ket1 * ket1.dag()) / 2
rho_mixed
# The trace of $\rho$ is written as $\Tr(\rho)$ and can be calculated using QuTiP's `.tr()` method:
(rho_mixed ** 2).tr()
rho_pure = ket_plus * ket_plus.dag()
rho_pure
(rho_pure ** 2).tr()
# > #### 💡 TIP
# >
# > More generally, a given matrix $\rho$ is a valid density operator if:
# >
# > 1. $\rho$ is a matrix of complex numbers,
# > 2. $\rho = \rho^{\dagger}$ (that is, $\rho$ is Hermitian),
# > 3. Every eigenvalue $p$ of $\rho$ is $0 <= p <= 1$, and
# > 4. All the eigenvalues of $\rho$ sum to 1.
# >
# > Together, these conditions guarantee that $\rho$ can be thought of as an ensemble, as we saw above. In particular, if $\rho = \sum_i p_i \ket{\psi_i} \bra{\psi_i}$ is an eigenvalue decomposition of $\rho$, then $\rho$ describes the ensemble $\rho = \{\ket{\psi_i} \text{ with probability } p_i\}$.
# For single qubit systems, we can even plot mixed states on the Bloch sphere in the same way we plot state vectors — doing so, pure states are those states that lie on the surface of the Bloch sphere, while mixed states in general can be "inside" the Bloch sphere.
plt.figure(figsize=(6, 6))
bloch = qt.bloch.Bloch()
bloch.add_states([rho_pure], kind='point')
bloch.show()
plt.figure(figsize=(6, 6))
bloch = qt.bloch.Bloch()
bloch.add_states([rho_mixed], kind='point')
bloch.show()
# We say that the state at the very center of the Bloch sphere is the _maximally mixed state_. Unlike pure states, the maximally mixed state returns 50/50 outcomes for any ideal Pauli measurement.
# ## Representing quantum processes
# Armed with the concept of a mixed state, we can now talk more concretely about how noisy processes affect the state of quantum registers. As before, it helps to take a step and consider how ideal unitary operations affect pure states.
#
# Considering the [`H` operation](https://docs.microsoft.com/qsharp/api/qsharp/microsoft.quantum.intrinsic.h), we can simulate its action on a pure state $\ket{\psi}$ as $H \ket{\psi}$. By direct analogy, we can simulate what `H` does to a density operator by multiplying on the left and right both:
# $$
# \begin{aligned}
# \rho \longmapsto H\rho H^{\dagger} = H \rho H.
# \end{aligned}
# $$
#
# More generally, though, we can also represent processes in which one of several unitary operations is applied at random. For example, suppose our `H` operation works 95% of the time, but the other 5% of the time does nothing. Just as we added different preparations together, we can simply add the density operators we get in each case, weighted by the probability of each case:
# $$
# \begin{aligned}
# \rho \longmapsto 0.95 H \rho H + 0.05 \rho.
# \end{aligned}
# $$
# One way to model this is by thinking of the `H` operation not as being represented by a unitary matrix, but by a function from density operators to density operators
# $$
# \begin{aligned}
# \Lambda_H(\rho) = H\rho H.
# \end{aligned}
# $$
# Since density functions represent an averge over different preparations, and since averages are linear, such functions must in general must also be linear.
#
# We say that a linear function from density operators to density operators is a _quantum process_.
#
# > **💡 TIP**:
# > Quantum processes that can be realized in practice have a few other conditions as well as linearity, known as *complete positivity* and *trace preservingness*. We say that a process that is both completely positive and trace preserving (CPTP) is a _channel_.
# >
# > You may see this terminology in contexts where the CPTP property is assumed.
#
# There's a few different ways to represent quantum processes, but the one we'll most commonly encounter in working with noise models for open quantum systems is known as _superoperators_. Just as operators are linear functions from vectors to vectors, superoperators are linear functions from operators to operators, and can be written using matrices.
#
# For example, let's use `qt.to_super` to convert a few unitary matrices that we're already used to into superoperators. We start by noting that the 2 × 2 identity operator $𝟙$ we use to simulate the `Microsoft.Quantum.Intrinsic.I` operation is a 4 × 4 identity matrix:
# Convert the 𝟙 matrix used to simulate Microsoft.Quantum.Intrinsic.I (single qubit no-op) into a superoperator.
qt.to_super(qt.qeye(2))
# That is, as we would expect, the superoperator we get from the identity operator maps all operators to themselves.
#
# On the other hand, we get something quite different for the $X$ matrix:
# Convert the 𝑋 matrix used to simulate Microsoft.Quantum.Intrinsic.X into a superoperator.
qt.to_super(qt.sigmax())
# What's happening above is that each column is a stack of the elements in an operator output by the function $\Lambda_X(\rho) = X \rho X^{\dagger} = X \rho X$.
#
# Since $\Lambda(\ket{0}\bra{0}) = X\ket{0} \bra{0}X = \ket{1}\bra{1}$, the first column is a stack of the elements of $\ket{1}\bra{1} = \left(\begin{matrix} 0 & 0 \\ 0 & 1 \end{matrix}\right)$. Similarly, the second column is a stack of the elements of $\Lambda_X(\ket{0}\bra{1}) = \ket{1}\bra{0}$:
np.array((ket1 * ket0.dag()).data.todense().flat)
# We can see the same pattern in converting other unitary operators such as $H$ and $Z$:
qt.to_super(qt.qip.operations.hadamard_transform())
qt.to_super(qt.sigmaz())
# Looking at the $Z$ example above in slightly more detail, we don't see a $-1$ sign in the lower-right hand corner because of the fact that density operators and superoperators do not have the same global phase ambiguity that state vectors and unitary operators do.
#
# In particular, consider acting the `Z` operation on a qubit in the $\ket{1}$ state. Simulating this with state vectors, we get that $Z \ket{1} = -\ket{1}$, where the $-$ sign in front of $\ket{1}$ is in this case an insignificant global phase. On the other hand, using open systems notation, we would simulate the same as $\Lambda_Z(\ket{1}\bra{1}) = Z\ket{1} \bra{1}Z^{\dagger} = Z\ket{1} \bra{1}Z = (-\ket{1})(-\bra{1}) = \ket{1}\bra{1}$, such that the global phases on the "ket" and "bra" parts of $\ket{1}\bra{1}$ cancel each other out.
#
# More generally, suppose that $U \ket{\phi} = e^{i\phi} \ket{\phi}$ for some unitary operator $U$, some phase $\phi$, and some state vector $\ket{\phi}$. Then since $\bra{\phi} U^\dagger = (U \ket{\phi})^\dagger = (e^{i \phi} \ket{\phi})^\dagger = \bra{\phi} e^{-i\phi}$, we get the same cancellation:
# $$
# \begin{aligned}
# \Lambda_U(\ket{\phi}\bra{\phi})
# & = U\ket{\phi}\bra{\phi}U^\dagger \\
# & = e^{i\phi} \ket{\phi}\bra{\phi} e^{-i\phi} \\
# & = \ket{\phi}\bra{\phi}.
# \end{aligned}
# $$
# On the other hand, relative phases are still represented in open systems notation, as we can confirm by looking at the matrices for $\ket{+}\bra{+}$ and $\ket{-}\bra{-}$:
ket_minus = (ket0 - ket1) / np.sqrt(2)
ket_minus
ket_plus * ket_plus.dag()
ket_minus * ket_minus.dag()
# That is, the off-diagonal elements of density operators tell us about the relative phases between each computational basis state.
#
# ## Noisy quantum processes
# Using superoperators not only allows us to represent familiar unitary operations, but also those functions from density operators to density operators that arise in describing noise. Returning to the example above, we can write $\Lambda(\rho) = 0.95 H\rho H + 0.05 \rho$ as a superoperator by simply summing the superoperators for `H` and `I` weighted by the probability for each case:
lambda_noisy_h = 0.95 * qt.to_super(qt.qip.operations.hadamard_transform()) + 0.05 * qt.to_super(qt.qeye(2))
lambda_noisy_h
# Unlike the unitary matrix $H$ that describes the ideal action of the `H` operation, the above superoperator allows us to simulate what happens when our `H` operation has a 5% probability of doing nothing instead.
#
# Let's hook this superoperator up to our Q# noise model and run `DumpPlus` again!
qsharp.config['experimental.simulators.nQubits'] = 1
qsharp.experimental.set_noise_model_by_name('ideal')
# Run with an ideal noise model first.
DumpPlus.simulate_noise()
noise_model = qsharp.experimental.get_noise_model_by_name('ideal')
noise_model['h'] = lambda_noisy_h
qsharp.experimental.set_noise_model(noise_model)
# Run again, using our new noisy superoperator for the `H` operation.
DumpPlus.simulate_noise()
# Comparing the two, we see that when we add a probability of the `H` operation failing into our noise model, the preview simulator uses the density operator representation together with our noise model to simulate the effect of that noise on the state of our qubits.
# There are many other kinds of noise as well. For example, if we have an equal probability of applying the `I`, `X`, `Y`, or `Z` operations to a single qubit, then we get _completely depolarizing noise_:
[I, X, Y, Z] = map(qt.to_super, [qt.qeye(2), qt.sigmax(), qt.sigmay(), qt.sigmaz()])
completely_depolarizing_process = 0.25 * (I + X + Y + Z)
completely_depolarizing_process
# From the above matrix, we can see that completely depolarizing noise maps all input density operators to the same output, namely $𝟙 / 2$. That is, completely depolarizing noise replaces whatever state we had with the maximially mixed state.
# We can also have depolarizing noise of a finite strength (that is, not completely depolarizing) by taking a linear combination of the identity and completely depolarizing processes:
def depolarizing_noise(strength=0.05):
return strength * completely_depolarizing_process + (1 - strength) * qt.to_super(I)
depolarizing_noise(0.05)
depolarizing_noise(0.25)
depolarizing_noise(0.5)
depolarizing_noise(1.0)
# So far, every example we've seen can be represented as a mixture of unitary operators, but there's also many kinds of noise that cannot be represented this way. For instance, by analogy to completely depolarizing noise, if we have a process that has some probability of resetting its input state, we can represent that as a mixture of a superoperator that _always_ resets and the identity process.
# To see this, let's start by writing down the process $\Lambda_{\text{Reset}}(\rho) = \Tr(\rho) \ket{0}\bra{0}$. Since this process does the same thing to each density operator we input, the first and fourth columns should be the same, namely $\left(\begin{matrix}1 & 0 & 0 & 0\end{matrix}\right)^{\text{T}}$.
#
# On the other hand, the second and third columns represent the output of $\Lambda_{\text{Reset}}$ acting on $\ket{0}\bra{1}$ and $\ket{1}\bra{0}$ respectively. Neither of these is a valid density operator on their own — indeed, $\Tr(\ket{0}\bra{1}) = \Tr(\ket{1}\bra{0})$ such that the $\Tr$ factor zeros out both of these columns.
lambda_reset = qt.Qobj([
[1, 0, 0, 1],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
], dims=completely_depolarizing_process.dims)
# We now have what we need to represent _amplitude damping_ noise, in which there's a finite chance of resetting each qubit:
def amplitude_damping_noise(strength=0.05):
return strength * lambda_reset + (1 - strength) * qt.to_super(I)
amplitude_damping_noise(0.05)
amplitude_damping_noise(0.25)
amplitude_damping_noise(0.5)
amplitude_damping_noise(1.0)
# ## Example: Decaying Ramsey signal
# Putting everything together by way of an example, let's see what happens if we repeatedly apply `S` to a qubit and then measure. While this may seem a bit contrived, it's good toy model for a kind of experiment known as _Ramsey interferometry_.
#
# In the absense of noise, we should see the signal that we get back oscillate with each iteration of `S`:
# +
# %%qsharp
operation ApplySRepeatedlyAndMeasure(nRepetions : Int) : Result {
use q = Qubit();
within {
H(q);
} apply {
for _ in 1..nRepetions {
S(q);
}
}
return MResetZ(q);
}
# -
qsharp.experimental.set_noise_model_by_name('ideal')
ns = np.arange(1, 101)
signal_wo_noise = [
sum(ApplySRepeatedlyAndMeasure.simulate_noise(nRepetions=n) for _ in range(100))
for n in ns
]
plt.plot(ns, signal_wo_noise)
# On the other hand, if our `S` has some finite amplitude damping noise, then we'll eventually see this signal decay:
S = qt.Qobj([
[1, 0],
[0, 1j]
])
noise_model = qsharp.experimental.get_noise_model_by_name('ideal')
noise_model['h'] = (
depolarizing_noise(0.025) *
qt.to_super(qt.qip.operations.hadamard_transform())
)
noise_model['s'] = (
amplitude_damping_noise(0.025) *
qt.to_super(S)
)
qsharp.experimental.set_noise_model(noise_model)
# Note that this cell can take a few moments to run.
signal = [
sum(ApplySRepeatedlyAndMeasure.simulate_noise(nRepetions=n) for _ in range(100))
for n in ns
]
plt.plot(ns, signal_wo_noise, label='Ideal Signal')
plt.plot(ns, signal, label='With Amplitude Damping Noise')
plt.legend()
# ## Next steps
# Having explored a bit of how to represent and simulate open quantum systems, there's a lot of great resources out there to help you take the next steps along your journey!
#
# Here's a couple suggestions for some great places to look for next steps:
#
# - [QuTiP documentation: Superoperators and Vectorized Operators](https://qutip.org/docs/latest/guide/guide-states.html#superoperators-and-vectorized-operators)
# - [Characterization, Verification and Control for Large Quantum Systems: Chapter 1](https://uwspace.uwaterloo.ca/bitstream/handle/10012/9217/Granade_Christopher.pdf)
# - [_Theory of Quantum Information_](https://cs.uwaterloo.ca/~watrous/TQI/)
# ## Epilogue
qsharp.component_versions()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab.research.google.com/github/GiselaCS/Mujeres_Digitales/blob/main/Clase6.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# + id="gbKOSCrHnFOt"
# + [markdown] id="CV5I6Qr-oUa-"
# **CONTINUACION DE LOS EJEMPLOS DEL USO DE LISTA DE COMPRENSION**
# ---
# *COMPRENSION DE CONJUNTOS*
#
# La comprension es muy similar a la que veniamos manejando con Lista. La unica diferencia es que se usan los {}
#
# Recordemos que los conjuntos tambien denonimados "sets", no permiten duplicados, es decir, cada elemento es unico. si se llega añadir un elemento repetido, no arroja error,
# + colab={"base_uri": "https://localhost:8080/"} id="Hbx-afmWpuoX" outputId="9449a110-1ba1-4c93-897b-47e8eed42f66"
sa="ema ama a mama"
#para cada valor que se puede iterar en sa, lo itera si algun valor es igual a m
sa2={i for i in sa if i=="m" }
print(sa2)
# + [markdown] id="kRUvuj3XqaRw"
# Ahora, veamos a continuacion el caso de diccionarios de comprensión.
#
# la unica diferencia que tiene respecto a las listas o conjuntos de compresion es la especificacon de llaves, o claves(key).
# + colab={"base_uri": "https://localhost:8080/"} id="bFz2gnORqv25" outputId="cc6801ef-ada6-4583-d6f6-d97fb254f31d"
#aqui estan las claves
lista=['nombre', "apellido", "ciudad"]
#aqui el contenido o informacion
lista2=["ana", "Rodiguez", "popayan"]
#i identifica la llave, y la j el contenido, zip conjunto de los datos
dict={i:j for i, j in zip(lista,lista2)}
print(dict)
# + [markdown] id="xp2xP4_fr1Fq"
# Pudimos observar que añadiendo :, asignamos un valor a la llave declarada, a su vez, usamos zip() el cual tiene, como funcion iterar dos listas en paralelo.
# es decir como zip podemos convertir dos listas en un diccionario y el for se manejaria iterando los valores en simultaneo.
#
#
#
# + [markdown] id="-uwjYzFrscT-"
# **OTRAS ESTRUCTURAS DE CONTROL**
# ---
# 1. Switch
# 2. Brak
# 3. Continue
# 4. Complemento de iteracion (Enumerate)
# + [markdown] id="CjyZYebOssqk"
# **1. Switch**
#
# esta es una herramienta, que permite ejecutar diferentes secciones de codigo dependiendo de las condiciones impuestas. Su funcion es muy similar a usar If anidados o varios por separados al mismo tiempo.
#
# sin embargo en python no hay un Switch directo.
#
# **2. break **
#
# Nos permite alterar el comportamiento de los ciclos de while y for, directamente su funcion es la de finalizar los ciclos.
# + colab={"base_uri": "https://localhost:8080/"} id="53X9JxbCt0_S" outputId="1d1affa5-a1ae-4d08-f2f1-d91eb0abcfc5"
x="Andrea"
for i in x:
if i == "e":
print("se obtuvo la letra e")
break
print(i)
# + colab={"base_uri": "https://localhost:8080/"} id="cuVMnkPlvEUJ" outputId="adda4686-d47e-4428-879e-56d753c1db50"
x = 15
while True:
x -=1
print(x)
if x==0:
break
print("Se finaliza el ciclo")
# + [markdown] id="2Feqb5tXu_IW"
#
# + colab={"base_uri": "https://localhost:8080/"} id="-vp_b8Z2wdh3" outputId="9554a742-f365-4635-d66c-4f6becaa8555"
#uso del break con los ciclos anidados
for i in range(1,8):
for j in range(1,8):
break
print(i,j)
#el break no afecta el for exterior, rompe el ciclo anidado en su conjunto, pero no afecta directamente el cilco exterior
# + [markdown] id="pzrFPHy9xok6"
# ** 2. Continue**
# ---
# El continue se salta todo el código restante en la iteración actual y vuelve al principio en caso que queden elementos por iterar.
#
# Diferencias entre break y continue: La printipal diferencia es que el continue NO rompe el ciclo si no que pasa a la iteración pendiente.
# + colab={"base_uri": "https://localhost:8080/"} id="7xeya6QmyWG8" outputId="be52e2a4-5c16-4569-a0a8-0f6f940972b3"
x= "Andrea"
for i in x:
if i=="r":
continue
print(i)
# + colab={"base_uri": "https://localhost:8080/"} id="QjoNrLsfyuR-" outputId="ac8334bc-e86f-4edc-abbe-5c08dd65e7c6"
x= 15
while x>0:
x -= 1
if x==3:
continue
print(x)
# + [markdown] id="QeVSvCm_zaGY"
# ** Iterar con enumerate**
# ---
# python nos permite iterar colecciones de objetos y elementos de la misma forma.
# sin embargo hay una opcion que es que en algunas situaciones que queramos acceder a un elemento ordenado podemos hacerlo, nombrando el indice de cada elemento llamado.
#
#
# + colab={"base_uri": "https://localhost:8080/"} id="UqCXFNFcz3Lm" outputId="a6e545da-3893-4233-cb3d-b0b70b6caff4"
w=["sa", "se", "si", "so", "su"]
indice =0
for i in w:
print(indice, i)
indice +=1
# + colab={"base_uri": "https://localhost:8080/"} id="xCV7fqyq0eQj" outputId="0930cf72-da2d-4056-9ff6-ac469fed9efb"
w=["sa", "se", "si", "so", "su"]
for indice, i in enumerate(w):
print(indice,1)
x= list(enumerate(w))
print(x)
# + [markdown] id="ag82bq0012j5"
# **Uso zip()**
# ---
# si pasamos dos listas a zip, el resultado sera una tupla donde cada elemento tendra todos y cada uno de los elementos de las entradas.
#
# + colab={"base_uri": "https://localhost:8080/"} id="FIt5okuA2Cfg" outputId="f3df700f-8eb3-4db1-dc97-10d3ab29f932"
a=[1,2,3]
b=["a", "b", "c"]
x=("q", "w", "e")
z=(10,20,30)
c=zip(a,b)
print(list(c))
for i, j, g, m in zip(a,b,x,z):
print("numero",i, "letras", j)
print(i,j,g,m)
# + colab={"base_uri": "https://localhost:8080/"} id="z4-ZcQi_4HuA" outputId="c13c3742-34e3-4057-bedb-b1d3734fd319"
#solo itera la misma cantidad de filas y columnas, es decir en este caso solo itera 2
a=[1,2,3]
b=["a", "b"]
for sa,se in zip(a,b):
print(sa,se)
# + colab={"base_uri": "https://localhost:8080/"} id="3yGkMmm-41iQ" outputId="7ecb171f-f623-4a1b-88e6-c0d8bf4a1ae3"
#para separar por categoria
c=[(1,"a"), (2,"b"), (3,"c")]
a,b=zip(*c)
print(a)
print(b)
# + [markdown] id="dZaku7a455az"
# **Funciones**
# ---
# la funcion nos permite ordenar de manera adecuada la generacion de objetos y bloques de codigo por ciclos y demas estructura.
#
# la sintaxis es la siguiente:
#
# def nombre_funcion(argumento):
#
# codigo
#
# nombre_funcion(argumento2)
#
# + colab={"base_uri": "https://localhost:8080/"} id="h4jSI1cr66e4" outputId="ac4e6664-c276-4e5a-b84a-15b87f236b30"
def f(a):
return 2*a
y=f(3)
print(y)
# + [markdown] id="sESppuK67mBE"
# Las funciones no sólo realizan una operación con sus entradas (argumentos de inicio), sino tambien parten de los siguientes principios:
#
# 1. Reusabilidad si tenemos un fragmento de código usado en muchos sitios, y se guardan en una función nos evitará tener códigos repetidos. Ademas de la conveniencia que tiene por ser facilmente editable.
#
# 2. Modularidad Permite legibilidad de forma mas sencilla, es decir, los largos bloques de código se pueden agrupar en modulos o funciones y la lectura va a ser mucho mas sencilla.
# + colab={"base_uri": "https://localhost:8080/"} id="I1xU3dvdIAo8" outputId="7fbdfa8c-be1b-4241-ceda-4832f1cf9c41"
#Ejemplo 1: Función SIN argumentos de entrada ni parametros de salida:
def s():
print("hi gisela") # hasta aqui DECLARCIÓN DE LA FUNCIÓN sale chulito verde al ejecutarla
s() #Al cerrar la definición de función me va aparecer la ejecución del código
# + colab={"base_uri": "https://localhost:8080/"} id="2sh6vO45IKAe" outputId="be49ef98-3f23-47da-81a1-7ed1b2bb46d6"
#Ejemplo 2: incluir argmentos de entrada
def s(apellido):
print("Hola gisela", apellido) #apelllido no tiene valor alguno
s("Criollo suarez") #cuando se cierrar la funcion le doy un valor de salida
# + colab={"base_uri": "https://localhost:8080/"} id="30sojYFyIT99" outputId="fc14ec05-99f3-4c07-df1a-b39f575432e6"
#Ejemplo 3: Usando dos argumentos en la entrada y salida y operación aritmetica
def suma(a,b):
return a+b #para no hacer declaracion y creacion de objetos de variables se usa asi el return
suma(3,5)
# + colab={"base_uri": "https://localhost:8080/"} id="7bxR4c5mI-e9" outputId="18bf5839-a2f0-4af8-a012-b0a80833e0db"
#Ejemplo 4: Reusabilidad del código
suma(a=5, b=25) # se esta llamando la funcion suma
# + colab={"base_uri": "https://localhost:8080/"} id="lAF-w7j1JCmZ" outputId="f5235325-dcc3-4d9b-a8c3-c4f6b7b37870"
#Ejemplo 5: Argumentos fijos desde el inicio
def suma(a,b,c,d=1):
return a+b+c+d
suma(2,3,4)
# + colab={"base_uri": "https://localhost:8080/"} id="yCuGkAKAJOWs" outputId="daf73e28-76d6-44f1-8b39-9e72854a10d1"
suma(5,6,7,8)
# + colab={"base_uri": "https://localhost:8080/"} id="2op28VvpJWf8" outputId="10c1cc20-c813-4832-a2fa-186e9a2eb942"
def suma(a=2,b=3, c=4,d=5): #declarados desde el inicio
return a+b+c+d
suma()
suma(1) #lo cambia en a
suma(1,5) # cambia los valores de a y b
suma(a=1, c=5) #modifica valores a y c
# + colab={"base_uri": "https://localhost:8080/"} id="BQ-G8mAoJiVv" outputId="f44be37b-7061-425a-c415-f9220afd492e"
#Ejemplo 6: Argumentos de longitud variable
def suma(number): #usa suma ejercicio anterior
total=0
for i in number:
total +=i
return total
suma([1,3,5,4])
# + [markdown] id="EHd8MIGZJpcw"
# *Nota*: Se realizó la suma de todos los números de entrada. para ello la declaración de los argumentos de salida sería como una lista.
#
# La forma de sintaxis anterior es valida, sin embargo tenemos un solo argumento que es una lista de números.
#
# Si declarramos un argumento con asterisco * esto hará que el argumento sea guardado como tupla de manera automática.
# + colab={"base_uri": "https://localhost:8080/"} id="zT_Z3cbRJ2fu" outputId="fd28d508-f2dc-4896-a2c7-281f8545cfd0"
def suma (*number):
print(type(number))
total=0
for i in number:
total+=i
return total
suma(2,3,5,4)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + id="rKFR_sphgXUJ" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 122} outputId="0570ddef-6afd-4247-b6d0-0e1c7ba1013d" executionInfo={"status": "ok", "timestamp": 1571732968095, "user_tz": -330, "elapsed": 34131, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
from google.colab import drive
drive.mount('/content/gdrive')
# + id="FZyhZMFqlSUW" colab_type="code" colab={}
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# + id="Wsvd4iNslx_2" colab_type="code" colab={}
dataset=pd.read_csv('gdrive/My Drive/Google_Stock_Price_Train.csv')
# + id="-jLTjQDtmCmd" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 204} outputId="b91b9fcf-6b03-4c59-a980-e946761d4284" executionInfo={"status": "ok", "timestamp": 1571733339890, "user_tz": -330, "elapsed": 1094, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
dataset.head()
# + id="aCjQe6edmzD6" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 136} outputId="7606d114-934e-412d-818c-795a7d164e14" executionInfo={"status": "ok", "timestamp": 1571733490007, "user_tz": -330, "elapsed": 1170, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
training_set=dataset.iloc[:,1:2].values
training_set
# + id="tuKTzMlUncJb" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 286} outputId="6715c9fb-e381-46ea-f484-5b0e26df2587" executionInfo={"status": "ok", "timestamp": 1571733622055, "user_tz": -330, "elapsed": 1444, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
plt.plot(training_set,color='red',label='5 Years Google Stock price')
# + id="b7YPQjRVn8YQ" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 136} outputId="5f57ce60-e742-4fad-ad08-c0ea0b4e9051" executionInfo={"status": "ok", "timestamp": 1571734105255, "user_tz": -330, "elapsed": 1385, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
#feature scaling
from sklearn.preprocessing import MinMaxScaler
sc=MinMaxScaler(feature_range=(0,1))
training_set_scaled=sc.fit_transform(training_set)
training_set_scaled
# + id="0rToQYnlpyRN" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 51} outputId="84496d95-8499-4ba0-f60e-f670f84a2bea" executionInfo={"status": "ok", "timestamp": 1571734307751, "user_tz": -330, "elapsed": 1303, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
# creating the data structure with 60 time spot and 1 out put
X_train=[]
y_train=[]
for i in range(60,1258):
X_train.append(training_set_scaled[i-60:i,0])
y_train.append(training_set_scaled[i,0])
X_train,y_train=np.array(X_train),np.array(y_train)
y_train
# + id="8DKV9nMSqf5t" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 34} outputId="05004f4e-0b95-48a4-c3d4-1b9ce1ee849e" executionInfo={"status": "ok", "timestamp": 1571735385401, "user_tz": -330, "elapsed": 1297, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
X_train=np.reshape(X_train,(X_train.shape[0],X_train.shape[1],1))
X_train.shape
# + id="pLApIwhaq48v" colab_type="code" colab={}
#building the RNN
#import the keras libraries and packages
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
# + id="fPQHj4kjryYc" colab_type="code" colab={}
#inintializing the RNN
regressor=Sequential()
# + id="UThw86jCr-C4" colab_type="code" colab={}
#adding the first lstm layer and some dropout regularisation
regressor.add(LSTM(units=50,return_sequences=True,input_shape=(X_train.shape[1],1)))
regressor.add(Dropout(0.2))
# + id="C1JU96j_sqtl" colab_type="code" colab={}
regressor.add(LSTM(units=50, return_sequences=True))
regressor.add(Dropout(0.2))
# + id="Qr1oAfYts2oJ" colab_type="code" colab={}
regressor.add(LSTM(units=50,return_sequences=True))
regressor.add(Dropout(0.2))
# + id="r2RqCe6YtRmk" colab_type="code" colab={}
regressor.add(LSTM(units=50))
regressor.add(Dropout(0.2))
# + id="2I9k8t12tavl" colab_type="code" colab={}
regressor.add(Dense(units=1))
# + id="Y8MTKGxNtib5" colab_type="code" colab={}
#compiling the rnn
regressor.compile(optimizer='adam',loss='mean_squared_error')
# + id="57AftwgbvVrL" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 34} outputId="5ed52f58-e02d-4a0f-b6fa-9eddc53ebf46" executionInfo={"status": "ok", "timestamp": 1571735594427, "user_tz": -330, "elapsed": 1348, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
X_train.shape
# + id="12IXBGq3vd8F" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 34} outputId="212d8828-02c4-42a5-ee39-c95cfa322565" executionInfo={"status": "ok", "timestamp": 1571735620901, "user_tz": -330, "elapsed": 880, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
y_train.shape
# + id="ffgQcqP2vkfp" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 1000} outputId="93aa54fd-b429-4831-c7ba-a5bade86a25d" executionInfo={"status": "ok", "timestamp": 1571736341782, "user_tz": -330, "elapsed": 660753, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
regressor.fit(X_train,y_train,epochs=100,batch_size=32)
# + id="Z35cg_epvzWT" colab_type="code" colab={}
#making the predection and visualising the results
#getting the real stock price of 2017
dataset_test=pd.read_csv('gdrive/My Drive/Google_Stock_Price_Test.csv')
real_stock_price=dataset_test.iloc[:,1:2].values
# + id="pX_jQOxAxeaJ" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 286} outputId="34c16bdf-8e8e-45e2-80b1-bc2cac83a849" executionInfo={"status": "ok", "timestamp": 1571736483120, "user_tz": -330, "elapsed": 1793, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
plt.plot(real_stock_price,color='red',label='Real Google Stock price')
# + id="3UaX2zFpxy48" colab_type="code" colab={}
#getting the predicted stock price of 2017
dataset_total=pd.concat((dataset['Open'],dataset_test['Open']),axis=0)
inputs=dataset_total[len(dataset_total)-len(dataset_test)-60:].values
inputs=inputs.reshape(-1,1)
inputs=sc.transform(inputs)
X_test=[]
for i in range(60,80):
X_test.append(inputs[i-60:i,0])
X_test=np.array(X_test)
X_test=np.reshape(X_test,(X_test.shape[0],X_test.shape[1],1))
predicted_stock_price=regressor.predict(X_test)
predicted_stock_price=sc.inverse_transform(predicted_stock_price)
# + id="Tkd_QcHY0egV" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 295} outputId="b322eb78-928d-4aa4-c95b-80008e342c0b" executionInfo={"status": "ok", "timestamp": 1571737422906, "user_tz": -330, "elapsed": 1524, "user": {"displayName": "Naveen. Kundurthi", "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCOVPR0BiydUIlDxRDQBDTzMT0W_QRImvR8REStgWg=s64", "userId": "05841676353733988512"}}
plt.plot(real_stock_price,color='red',label='real google price')
plt.plot(predicted_stock_price,color='blue',label='predicted google stock price')
plt.title('google stock price prediction')
plt.xlabel('time')
plt.ylabel('google stock price')
plt.legend()
plt.show()
# + id="TysFPP422cOx" colab_type="code" colab={}
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Read-Image
# #### Repositório para testes da biblioteca OpenCV, o projeto destinasse a identificar padrões em imagens
#importa todas as bibliotecas usadas
import matplotlib.pyplot as plt
import numpy as np
import cv2 as cv
# ##### Carregar a imagem base das derivadas que serão analisadas
#Carregando gabarito base em escala de cinza
gBase = cv.imread('dataset/imgs/gabarito_template_geral.png', cv.IMREAD_GRAYSCALE)
plt.imshow(gBase)
plt.show()
# #### Carregar o gabarito já preenchido
gPreenchido = cv.imread('dataset/imgs/gabarito_template_geral_preenchido.png', cv.IMREAD_GRAYSCALE)
plt.imshow(gPreenchido)
plt.show()
# ###### Identificando a diferença entre o gabarito base e o preenchido
gDiferenca = cv.subtract(gBase,gPreenchido) #Identificando as diferenças entre os gabaritos
_,gDiferenca = cv.threshold(gDiferenca, 155, 255, cv.THRESH_OTSU) #tornando a diferença uma img binária
kernel = np.ones((5,5),np.uint8) #definindo o quadrado para cobrir as falhas
gDiferencaClose = cv.morphologyEx(gDiferenca,
cv.MORPH_CLOSE,
kernel) #cobrindo as falhas existentes na img diferença
plt.imshow(gDiferencaClose)
plt.show()
# Após identificar a diferença entre os gabaritos, os mesmos podem ser analisados para identificar qual a questão corresponde a marcada
def find_shapes(img):
# Configuração dos parâmetros do SimpleBlobDetector.
params = cv.SimpleBlobDetector_Params()
# Alterar limites
params.minThreshold = 100;
params.maxThreshold = 5000;
# Filtrar por Área.
params.filterByArea = True
params.minArea = 20
# Filtrar por Circularidade
params.filterByCircularity = False
params.minCircularity = 0.785
# Filtrar por convexidade
params.filterByConvexity = False
params.minConvexity = 0.87
# Filtrar por Inércia
params.filterByInertia = True
params.minInertiaRatio = 0.01
# Criando o detector baseado na versão do CV
is_cv3 = cv.__version__.startswith("3.")
if is_cv3:
detector = cv.SimpleBlobDetector_create()
else:
detector = cv.SimpleBlobDetector()
#Detectando corpos
keypoints = detector.detect(img)
# Criando nova imagem com os elementos identificandos pelo detector
im_with_keypoints = cv.drawKeypoints(img, keypoints, np.array([]),
(0,0,255), cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv.imwrite("dataset/imgs/identificadas/shapes.jpg", im_with_keypoints);
find_shapes(gDiferenca)
img = cv.imread('dataset/imgs/identificadas/shapes.jpg', cv.IMREAD_GRAYSCALE)
plt.imshow(img)
plt.show()
# Foi possivei identificar que muitos elementos além das possíveis respostas são identificadas, por isso a imagem deve ser refinada, podendo assim identificar pontos centrais das respostas
gDiferencaLimpa = cv.erode(gDiferencaClose, kernel, iterations=-1) #refinando a aproximação do ponto
plt.imshow(gDiferencaLimpa)
plt.show()
# ##### Enumerando as respostas
# +
import cv2
import numpy as np
cap = cv2.VideoCapture(0)
while(True):
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#frame = cv2.flip(frame,1)
_,frame_bin = cv2.threshold(gray, 0, 255, cv2.THRESH_TOZERO) #tornando a diferença uma img binária
th2 = cv2.adaptiveThreshold(gray,255,cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY,11,2)
th3 = cv2.adaptiveThreshold(frame_bin,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
cv2.imshow("frame_bin",frame_bin)
cv2.imshow("th2",th2)
cv2.imshow("th3",th3)
if (cv2.waitKey(1) & 0xFF == ord('q')):
break
cap.release()
cv2.destroyAllWindows()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import os
import pandas as pd
import numpy as np
import seaborn as sns; sns.set()
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import confusion_matrix
from statsmodels.discrete.discrete_model import Logit, LogitResults
# -
pd.set_option('max_columns', 200)
pd.set_option('max_rows', 200)
pd.set_option('display.float_format', '{:.2f}'.format)
df = pd.read_pickle('../Chapter 7 - Data Preparation and Visualization/claims_df')
df.shape
disease = ['SP_ALZHDMTA','SP_CHF', 'SP_CHRNKIDN', 'SP_CNCR', 'SP_COPD', 'SP_DEPRESSN','SP_DIABETES', 'SP_ISCHMCHT', 'SP_OSTEOPRS', 'SP_RA_OA', 'SP_STRKETIA']
gender = ['gender_2']
ESRD = ['ESRD_Y']
X = df[disease+gender+ESRD]
y = df.HIGH_COST
lab_enc = LabelEncoder()
lab_enc.fit_transform(y)
lm = LogisticRegression()
lm.fit(X, y)
lm.score(X, y)
def generate_conf_mat(model, X, y):
conf_mat = confusion_matrix(model.predict(X), y)
conf_mat = pd.DataFrame(conf_mat/conf_mat.sum())
conf_mat.columns = ['0_pred', '1_pred']
conf_mat.index=['0_actual', '1_actual']
return conf_mat
conf_mat = generate_conf_mat(lm, X, y)
conf_mat
# # Use statsmodels
lm2 = Logit(y, X)
results = lm2.fit()
results.summary()
# # Approach using svm
from sklearn.svm import LinearSVC
mod = svm.LinearSVC(class_weight='balanced')
mod.fit(X, y)
conf_mat = generate_conf_mat(mod, X, y)
conf_mat
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
from collections import Counter
import json
import datetime as dt
import numpy as np
import pandas as pd
import dask.bag as db
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, label_binarize, normalize
from sklearn.metrics import f1_score, auc, roc_auc_score, roc_curve, precision_score, recall_score, accuracy_score, precision_recall_curve, confusion_matrix
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.linear_model import LogisticRegression
# from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline, FeatureUnion
from functions.data import (bag_to_df,
flatten_review, flatten_business,
preprocess_review_df, preprocess_business_df)
from functions.model import compute_multiclass_ROC, TextSelector, NumberSelector
# Logistic regression works the best
# GaussianNB, DecisionTree, and RandomForest are poor
# SVC and XGBoost will crash
# -
save=False
# # Get Data
# +
review_bag = db.read_text("data/reviews.json").map(json.loads) # Loads the json file as a dask bag
review_df = bag_to_df(review_bag, flatten_review)
review_df = preprocess_review_df(review_df)
business_bag = db.read_text("data/business.json").map(json.loads) # Loads the json file as a dask bag
business_df = bag_to_df(business_bag, flatten_business)
business_df = preprocess_business_df(business_df)
# merge
business_review_df = pd.merge(business_df, review_df, on="business_id")
business_review_df.columns
# -
# # Logistic Regresssion on Text Only
# +
# Set aside 20% of data for out of sample validation, using date to filter
features_list = ['text_length','useful','review_count', 'Dogs Allowed', 'funny',
'Open to All', 'Accepts Credit Cards', 'cool',
'Bike Parking', 'Good for Kids', 'avg_stars', 'text_clean']
features_train_df = business_review_df[business_review_df['date'] <= dt.datetime(2017, 5, 28)][features_list]
features_test_df = business_review_df[business_review_df['date'] > dt.datetime(2017, 5, 28)][features_list]
target_train_ser = business_review_df[business_review_df['date'] <= dt.datetime(2017, 5, 28)]['stars']
target_test_ser = business_review_df[business_review_df['date'] > dt.datetime(2017, 5, 28)]['stars']
# Binarize output
target_train_bin_array = label_binarize(target_train_ser, classes= [1, 2, 3, 4, 5])
target_test_bin_array = label_binarize(target_test_ser, classes = [1, 2, 3, 4, 5])
# +
# Preprocessing steps
# Count Vectorizer
count_vectorizer = CountVectorizer(stop_words='english', ngram_range=(1,3)) #ngram_range=(1,3)
features_train_vectorized_csr = count_vectorizer.fit_transform(features_train_df['text_clean']) # csr
features_test_vectorized_csr = count_vectorizer.transform(features_test_df['text_clean'])
# -
logreg_mlt_clf = LogisticRegression(multi_class = 'multinomial', solver = 'newton-cg') # Initialize
logreg_mlt_clf.fit(features_train_vectorized_csr, target_train_ser) # Train
# # Unweighted
# +
# Unweighted
features_train_vectorized_predict_array = logreg_mlt_clf.predict(features_train_vectorized_csr) # Needed for confusion matrix
features_train_vectorized_proba_array = logreg_mlt_clf.predict_proba(features_train_vectorized_csr)
features_test_vectorized_predict_array = logreg_mlt_clf.predict(features_test_vectorized_csr) # Needed for confusion matrix
features_test_vectorized_proba_array = logreg_mlt_clf.predict_proba(features_test_vectorized_csr)
confusion = confusion_matrix(target_test_ser, features_test_vectorized_predict_array)
confusion_normalized_array = normalize(confusion, axis=1, norm='l1') # Total Test accuracy to within +/- 1 class,
print("Micro-Average Training Accuracy: ", f1_score(target_train_ser, features_train_vectorized_predict_array, average = "micro"))
print("Micro-Average Test Accuracy: ", f1_score(target_test_ser, features_test_vectorized_predict_array, average = "micro"))
print("Micro-Average Test Accuracy: ", confusion.trace()/confusion.sum()) # Total Test Accuracy Score
# Average Test Accuracy to within +/- 1 class
print("Macro-Average Test Accuracy (+/-1): ", sum([confusion_normalized_array[1:, :-1].trace()/5, confusion_normalized_array.trace()/5, confusion_normalized_array[:-1, 1:].trace()/5]))
# +
# Unweighted
# Plot Multiclass Confusion Matrix
fig = plot_heatmap(confusion, xlabel='Predicted', ylabel='Actual', title='Confusion Matrix',
xticklabels=['1', '2', '3', '4', '5'], yticklabels=['1', '2', '3', '4', '5'],
color='Blues', annot=True, fmt='d', dpi=80)
if save:
plt.savefig("figures/classification/confusion-unweighted.png", transparent=False, bbox_inches="tight")
# Plot Distribution for Each Class
star_ratings = range(1, 6)
fig, ax = plot_empty(xlabel='Model Prediction', ylabel='Fraction of Predictions', title='Reviews Assigned Per Class',
figsize=(12, 8))
for i in range(5):
ax.plot(star_ratings, confusion_normalized_array[i], label='{0}-Star'.format(i+1), lw=2)
ax.set_xlim(1, 5)
ax.set_ylim(0, 1)
ax.set_xticks(star_ratings)
plt.legend(loc="lower right")
ax.xaxis.grid(True)
if save:
plt.savefig("figures/classification/class-predictions-unweighted.png", transparent=False, bbox_inches="tight")
# -
# # Weighted
# +
# Weighted
# Thresholds
count_dict = Counter(target_train_ser)
class_weight = np.array([1/count_dict[1], 1/count_dict[2], 1/count_dict[3], 1/count_dict[4], 1/count_dict[5]])
# Generating new predict and proba variables
features_train_vectorized_proba_array_new = normalize(features_train_vectorized_proba_array * class_weight, axis=1, norm='l1')
features_train_vectorized_predict_array_new = np.argmax(features_train_vectorized_proba_array_new, axis=1)+1 # Needed for confusion matrix
features_test_vectorized_proba_array_new = normalize(features_test_vectorized_proba_array * class_weight, axis=1, norm='l1')
features_test_vectorized_predict_array_new = np.argmax(features_test_vectorized_proba_array_new, axis=1)+1 # Needed for confusion matrix
confusion = confusion_matrix(target_test_ser, features_test_vectorized_predict_array_new)
confusion_normalized_array = normalize(confusion, axis=1, norm='l1')
print("Weighted Micro-Average Training Accuracy: ", f1_score(target_train_ser, features_train_vectorized_predict_array_new, average = "micro"))
print("Weighted Micro-Average Test Accuracy: ", f1_score(target_test_ser, features_test_vectorized_predict_array_new, average = "micro"))
print("Weighted Micro-Average Test Accuracy: ", confusion.trace()/confusion.sum()) # Average Test Accuracy
# Average Test Accuracy to within +/- 1 class
print("Weighted Macro-Average Test Accuracy (+/-1): ", sum([confusion_normalized_array[1:, :-1].trace()/5, confusion_normalized_array.trace()/5, confusion_normalized_array[:-1, 1:].trace()/5]))
# +
# Weighted
# Plot Multiclass Confusion Matrix
fig = plot_heatmap(confusion, xlabel='Predicted', ylabel='Actual', title='Confusion Matrix',
xticklabels=['1', '2', '3', '4', '5'], yticklabels=['1', '2', '3', '4', '5'],
color='Blues', annot=True, fmt='d', dpi=80)
if save:
plt.savefig("figures/classification/confusion-weighted.png", transparent=False, bbox_inches="tight")
# Plot Distribution for Each Class
star_ratings = range(1, 6)
fig, ax = plot_empty(xlabel='Model Prediction', ylabel='Fraction of Predictions', title='Reviews Assigned Per Class',
figsize=(12, 8))
for i in range(5):
ax.plot(star_ratings, confusion_normalized_array[i], label='{0}-Star'.format(i+1), lw=2)
ax.set_xlim(1, 5)
ax.set_ylim(0, 1)
ax.set_xticks(star_ratings)
plt.legend(loc="lower right")
ax.xaxis.grid(True)
if save:
plt.savefig("figures/classification/class-predictions-weighted.png", transparent=False, bbox_inches="tight")
# +
# Compute Multiclass ROC
fpr, tpr, thresholds, roc_auc = compute_multiclass_ROC(target_test_bin_array, features_test_vectorized_proba_array_new)
# Plot Micro-ROC curve for Weighted Test set
fig, ax = plot_empty(xlabel='False Positive Rate', ylabel='True Positive Rate', title='ROC Curve',
figsize=(12, 8))
for i in range(5):
plt.plot(fpr[i], tpr[i], label='ROC curve of class {0} (area = {1:1.4f})'.format(i+1, roc_auc[i]), lw=2)
plt.plot(fpr["micro"], tpr["micro"], label='micro-average ROC curve (area = {0:0.4f})'.format(roc_auc["micro"]), lw=2)
plt.plot(fpr["macro"], tpr["macro"], label='macro-average ROC curve (area = {0:0.4f})'.format(roc_auc["macro"]), color='deeppink', lw=2)
plt.plot([0, 1], [0, 1], c='orange', lw = 2, ls='--', label= "Random Guess")
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.legend(loc="lower right")
if save:
plt.savefig("figures/classification/roc-weighted.png", transparent=False, bbox_inches="tight")
# -
# # Logistic Regression on Text and Categorical Features
# +
# Build the pipeline
count = Pipeline([('selector', TextSelector(key='text_clean')),
('count_vectorizer', CountVectorizer(stop_words='english', ngram_range=(1,3)))])
tfidf = Pipeline([('selector', TextSelector(key='text_clean')),
('tfidf_vectorizer', TfidfVectorizer(stop_words='english', ngram_range=(1,3)))])
text_length = Pipeline([('selector', NumberSelector(key='text_length')),
('scaler', StandardScaler())])
useful = Pipeline([('selector', NumberSelector(key='useful')),
('scaler', StandardScaler())])
review_count = Pipeline([('selector', NumberSelector(key='review_count')),
('scaler', StandardScaler())])
dogs_allowed = Pipeline([('selector', NumberSelector(key='Dogs Allowed')),
('scaler', StandardScaler())])
funny = Pipeline([('selector', NumberSelector(key='funny')),
('scaler', StandardScaler())])
open_to_all = Pipeline([('selector', NumberSelector(key='Open to All')),
('scaler', StandardScaler())])
accepts_credit_cards = Pipeline([('selector', NumberSelector(key='Accepts Credit Cards')),
('scaler', StandardScaler())])
cool = Pipeline([('selector', NumberSelector(key='cool')),
('scaler', StandardScaler())])
bike_parking = Pipeline([('selector', NumberSelector(key='Bike Parking')),
('scaler', StandardScaler())])
good_for_kids = Pipeline([('selector', NumberSelector(key='Good for Kids')),
('scaler', StandardScaler())])
avg_stars = Pipeline([('selector', NumberSelector(key='avg_stars')),
('scaler', StandardScaler())])
feats = FeatureUnion([('count', count),
('tfidf', tfidf),
('text_length', text_length),
('useful', useful),
('review_count', review_count),
('Dogs Allowed', dogs_allowed),
('funny', funny),
('Open to All', open_to_all),
('Accepts Credit Cards', accepts_credit_cards),
('cool', cool),
('Bike Parking', bike_parking),
('Good for Kids', good_for_kids),
('avg_stars', avg_stars)])
# Create the pipeline
pipeline = Pipeline([
('feats', feats),
('logreg_mlt_pipe clf', LogisticRegression(multi_class = 'multinomial', solver = 'newton-cg')),
])
# +
# Process the features
feature_processing = Pipeline([('feats', feats)])
feature_processing.fit_transform(features_train_df)
# Fit, takes a while
pipeline.fit(features_train_df, target_train_ser)
# -
# # Unweighted
# +
# Unweighted
features_train_vectorized_predict_array = pipeline.predict(features_train_df) # Needed for confusion matrix
features_train_vectorized_proba_array = pipeline.predict_proba(features_train_df)
features_test_vectorized_predict_array = pipeline.predict(features_test_df) # Needed for confusion matrix
features_test_vectorized_proba_array = pipeline.predict_proba(features_test_df)
confusion = confusion_matrix(target_test_ser, features_test_vectorized_predict_array)
confusion_normalized_array = normalize(confusion, axis=1, norm='l1')
print("Unweighted Training Accuracy Score: ", f1_score(target_train_ser, features_train_vectorized_predict_array, average = "micro"))
print("Unweighted Test Accuracy Score: ", f1_score(target_test_ser, features_test_vectorized_predict_array, average = "micro"))
print("Micro-Average Test Accuracy: ", confusion.trace()/confusion.sum()) # Un-weighted accuracy
# Un-weighted accuracy to within +/- 1 class
print("Macro-Average Test Accuracy (+/-1): ", sum([confusion_normalized_array[1:, :-1].trace()/5, confusion_normalized_array.trace()/5, confusion_normalized_array[:-1, 1:].trace()/5]))
# +
# Unweighted
# Plot Multiclass Confusion Matrix
fig = plot_heatmap(confusion, xlabel='Predicted', ylabel='Actual', title='Confusion Matrix',
xticklabels=['1', '2', '3', '4', '5'], yticklabels=['1', '2', '3', '4', '5'],
color='Blues', annot=True, fmt='d', dpi=80)
if save:
plt.savefig("figures/feature-union/confusion-unweighted.png", transparent=False, bbox_inches="tight")
# Plot Distribution for Each Class
star_ratings = range(1, 6)
fig, ax = plot_empty(xlabel='Model Prediction', ylabel='Fraction of Predictions', title='Reviews Assigned Per Class',
figsize=(12, 8))
for i in range(5):
ax.plot(star_ratings, confusion_normalized_array[i], label='{0}-Star'.format(i+1), lw=2)
ax.set_xlim(1, 5)
ax.set_ylim(0, 1)
ax.set_xticks(star_ratings)
plt.legend(loc="lower right")
ax.xaxis.grid(True)
if save:
plt.savefig("figures/feature-union/class-prediction-unweighted.png", transparent=False, bbox_inches="tight")
# -
# # Weighted
# +
# Weighted
# New Thresholds
count_dict = Counter(target_train_ser)
threshold_array = np.array([1/count_dict[1], 1/count_dict[2], 1/count_dict[3], 1/count_dict[4], 1/count_dict[5]])
# Generating new predict and proba variables
features_train_vectorized_proba_array_new = normalize(features_train_vectorized_proba_array * threshold_array, axis=1, norm='l1')
features_train_vectorized_predict_array_new = np.argmax(features_train_vectorized_proba_array_new, axis=1)+1 # Needed for confusion matrix
features_test_vectorized_proba_array_new = normalize(features_test_vectorized_proba_array * threshold_array, axis=1, norm='l1')
features_test_vectorized_predict_array_new = np.argmax(features_test_vectorized_proba_array_new, axis=1)+1 # Needed for confusion matrix
confusion = confusion_matrix(target_test_ser, features_test_vectorized_predict_array_new)
confusion_normalized_array = normalize(confusion, axis=1, norm='l1')
print("Weighted Micro-Average Training Accuracy: ", f1_score(target_train_ser, features_train_vectorized_predict_array_new, average = "micro"))
print("Weighted Micro-Average Test Accuracy: ", f1_score(target_test_ser, features_test_vectorized_predict_array_new, average = "micro"))
print("Weighted Micro-Average Test Accuracy: ", confusion.trace()/confusion.sum()) # Average Test Accuracy
# Average Test Accuracy to within +/- 1 class
print("Weighted Macro-Average Test Accuracy (+/-1): ", sum([confusion_normalized_array[1:, :-1].trace()/5, confusion_normalized_array.trace()/5, confusion_normalized_array[:-1, 1:].trace()/5]))
# +
# Reweighted
# Plot Multiclass Confusion Matrix
fig = plot_heatmap(confusion, xlabel='Predicted', ylabel='Actual', title='Confusion Matrix',
xticklabels=['1', '2', '3', '4', '5'], yticklabels=['1', '2', '3', '4', '5'],
color='Blues', annot=True, fmt='d', dpi=80)
if save:
plt.savefig("figures/feature-union/confusion-weighted.png", transparent=False, bbox_inches="tight")
# Plot Distribution for Each Class
star_ratings = range(1, 6)
fig, ax = plot_empty(xlabel='Model Prediction', ylabel='Fraction of Predictions', title='Reviews Assigned Per Class',
figsize=(12, 8))
for i in range(5):
ax.plot(star_ratings, confusion_normalized_array[i], label='{0}-Star'.format(i+1), lw=2)
ax.set_xlim(1, 5)
ax.set_ylim(0, 1)
ax.set_xticks(star_ratings)
plt.legend(loc="lower right")
ax.xaxis.grid(True)
if save:
plt.savefig("figures/feature-union/class-predictions-weighted.png", transparent=False, bbox_inches="tight")
# +
# Compute Multiclass ROC for training set
fpr, tpr, thresholds, roc_auc = compute_multiclass_ROC(target_test_bin_array, features_test_vectorized_proba_array_new)
# Plot Micro-ROC curve for Weighted Test set
fig, ax = plot_empty(xlabel='False Positive Rate', ylabel='True Positive Rate', title='ROC Curve',
figsize=(12, 8))
for i in range(5):
plt.plot(fpr[i], tpr[i], label='ROC curve of class {0} (area = {1:1.4f})'.format(i+1, roc_auc[i]), lw=2)
plt.plot(fpr["micro"], tpr["micro"], label='micro-average ROC curve (area = {0:0.4f})'.format(roc_auc["micro"]), lw=2)
plt.plot(fpr["macro"], tpr["macro"], label='macro-average ROC curve (area = {0:0.4f})'.format(roc_auc["macro"]), color='deeppink', lw=2)
plt.plot([0, 1], [0, 1], c='orange', lw = 2, ls='--', label= "Random Guess")
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.legend(loc="lower right")
if save:
plt.savefig("figures/feature-union/roc-weighted.png", transparent=False, bbox_inches="tight")
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# ---
from fastai.vision.all import *
from fastai.vision.widgets import *
path = Path()
learn_inf = load_learner(path/'bear_detect.pkl')
btn_upload = widgets.FileUpload()
lbl_pred = widgets.Label()
out_pl = widgets.Output()
btn_run = widgets.Button(description='Classify Bear')
# +
def on_click_classify(change):
img = PILImage.create(btn_upload.data[-1])
out_pl.clear_output()
with out_pl: display(img.to_thumb(128,128))
pred,pred_idx,probs = learn_inf.predict(img)
lbl_pred.value = f'Prediction: {pred}; Probability: {probs[pred_idx]:.04f}'
btn_run.on_click(on_click_classify)
# -
# ### Create Design
# +
VBox([
widgets.Label('Select your bear to predict!'),
btn_upload,
btn_run,
out_pl,
lbl_pred
])
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Import
import numpy as np
import cv2
# ## Rescale of Video Frame
def rescale_frame(frame, scale_percent = 100):
width = int(frame.shape[1] * scale_percent / 100)
height = int(frame.shape[0] * scale_percent / 100)
dim = (width, height)
return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)
# ## Background Substractor
# +
cap = cv2.VideoCapture(r'Video Files\sample1.mp4')
# Various Background Substractor Algorithms
fgbg1 = cv2.bgsegm.createBackgroundSubtractorMOG()
fgbg2 = cv2.createBackgroundSubtractorMOG2(varThreshold = 40, detectShadows = False)
fgbg3 = cv2.createBackgroundSubtractorKNN(dist2Threshold = 250, detectShadows = False)
while True:
ret, frame = cap.read()
if frame is None:
break
frame = rescale_frame(frame, 40)
fgmask1 = fgbg1.apply(frame);
fgmask2 = fgbg2.apply(frame);
fgmask3 = fgbg3.apply(frame);
cv2.imshow('Original', frame);
cv2.imshow('MOG', fgmask1);
cv2.imshow('MOG2', fgmask2);
cv2.imshow('KNN', fgmask3);
k = cv2.waitKey(1) & 0xFF
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
# -
# # A Sample of the working Code
# 
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Run All
#
# A shortcut multi-notebook script for running and re-running the entire project workflow.
# %pwd
# %run '0_clear_caches.ipynb'
# %run '1_import_data.ipynb'
# %run '2_clean_data.ipynb'
# %run '3_make_topic_model.ipynb'
# !jupyter nbconvert --to notebook --execute 4_make_topic_browser.ipynb
# http://mirrormask.english.ucsb.edu:10001/{project_name}/browser/
# -------------
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Feature Generation (no Index support)
#
# Both Solr and Elasticsearch (and possibly other indexes that support LTR) provide support in generating query document features, such as similarities. Here we will assume that we have a search index (we will use Solr) which hosts the data already, so no need to load the data.
#
# We will use third party similarity functions to generate our similarity features. Output will be a file in LETOR format similar to the other two cases.
#
# NOTE: one nice thing is that we are now free to come up with more novel similarity features, such as cosine similarity of query and document vectors generated from word embeddings, or include features that may be difficult to store in the index because of its volatility (for example, user preferences).
#
# Solr needs to be running and listening on port 8983. If it is not up, start with:
#
# bin/solr start -Dsolr.ltr.enabled=true
#
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel
import datetime
import gensim
import json
import numpy as np
import os
import random
import requests
import spacy
import urllib
# +
DATA_DIR = "../../data"
SOLR_URL = "http://localhost:8983/solr/tmdbindex/"
LETOR_FILE_TEMPLATE = os.path.join(DATA_DIR, "diy_features_{:s}.txt")
FEATURE_LIST = [
"origScore", "titleSimTFIDF", "titleSimBM25", "descSimTFIDF", "descSimBM25",
"docRecency", "isGoHands", "isAniplex", "isThriller", "isForeign",
"isDrama", "isWar", "isAction", "isComedy", "isMusic",
"isRomance", "isAdventure", "isFamily", "isFantasy", "isCrime",
"isHorror", "isHistory", "isMystery", "isAnimation", "isDocumentary",
"isWestern"
]
QUERY_LIST = [
"murder", "musical", "biography", "police", "world war ii",
"comedy", "superhero", "nazis", "romance", "martial arts",
"extramarital", "spy", "vampire", "magic", "wedding",
"sport", "prison", "teacher", "alien", "dystopia"
]
# -
nlp = spacy.load("en")
# +
def get_search_results(query, num_docs):
payload = {
"q": query,
"defType": "edismax",
"qf": "title_t description_t",
"pf": "title_t description_t",
"mm": 2,
"fl": "*,score",
"rows": num_docs
}
params = urllib.parse.urlencode(payload, quote_via=urllib.parse.quote_plus)
search_url = SOLR_URL + "select?" + params
resp = requests.get(search_url)
resp_json = json.loads(resp.text)
docs = resp_json["response"]["docs"]
return docs
docs = get_search_results("martial arts", 100)
assert(len(docs) <= 100)
# -
# ## TF-IDF Similarity
# +
def get_tfidf_similarities(query, docs, field_name):
fields = []
for doc in docs:
try:
fields.append(doc[field_name])
except KeyError:
fields.append(" ")
tfidf = TfidfVectorizer()
field_vecs = tfidf.fit_transform(fields)
query_vec = np.sum(tfidf.transform(query.split(" ")), axis=0)
sims = linear_kernel(query_vec, field_vecs).flatten()
tfidf = None
return sims
desc_sims_tfidf = get_tfidf_similarities("martial arts", docs, "description_t")
assert(len(desc_sims_tfidf) == len(docs))
# -
# ## BM25 Similarity
# +
def get_bm25_similarities(query, docs, field_name):
""" Code adapted from:
https://stackoverflow.com/questions/40966014/how-to-use-gensim-bm25-ranking-in-python
"""
fields = []
for doc in docs:
try:
fields.append(nlp(doc[field_name].lower()))
except KeyError:
fields.append(nlp(" "))
field_tokens = []
for field in fields:
field_tokens.append([token.text for token in field])
dictionary = gensim.corpora.Dictionary(field_tokens)
corpus = [dictionary.doc2bow(token) for token in field_tokens]
bm25 = gensim.summarization.bm25.BM25(corpus)
avg_idf = sum(float(val) for val in bm25.idf.values()) / len(bm25.idf)
query_tokens = [token.text for token in nlp(query.lower())]
query_vec = dictionary.doc2bow(query_tokens)
sims = bm25.get_scores(query_vec, avg_idf)
dictionary, corpus, bm25 = None, None, None
return sims
desc_sims_bm25 = get_bm25_similarities("martial arts", docs, "description_t")
assert(len(desc_sims_bm25) == len(docs))
# -
# ## Document Recency
#
# We will get this as the number of seconds since epoch divided by `365*24*60*60` (so decimal value in years).
# +
def get_doc_recencies(docs, field_name):
epoch = datetime.datetime.utcfromtimestamp(0)
recencies = []
for doc in docs:
try:
field = doc[field_name]
field_dttm = datetime.datetime.strptime(doc[field_name], "%Y-%m-%dT%H:%M:%SZ")
total_years = (field_dttm - epoch).total_seconds() / (365 * 24 * 60 * 60)
except KeyError:
total_years = 0
recencies.append(total_years)
return recencies
doc_recencies = get_doc_recencies(docs, "released_dt")
assert(len(doc_recencies) == len(docs))
# -
# ## Document Categories
# +
def get_doc_categories(docs):
categories = []
for doc in docs:
category_dict = {}
try:
genres = set(doc["genres_ss"])
for feature in FEATURE_LIST[6:]:
feat_val = feature[2:]
if feat_val in genres:
category_dict[feature] = 1
else:
category_dict[feature] = 0
except KeyError:
category_dict = {feature: 0 for feature in FEATURE_LIST[6:]}
categories.append(category_dict)
return categories
categories = get_doc_categories(docs)
assert(len(categories) == len(docs))
# -
# ## Generate Features
# +
def rating2label(rating):
""" convert 0-10 continuous rating to 1-5 categorical labels """
return int(rating // 2) + 1
assert(rating2label(6.4) == 4)
assert(rating2label(9.8) == 5)
# +
feature_name2id = {name: idx + 1 for idx, name in enumerate(FEATURE_LIST)}
assert(feature_name2id["isRomance"] == 16)
# -
def format_letor(doc_id, rating, qid, query, orig_score, title_sim_tfidf, desc_sim_tfidf,
title_sim_bm25, desc_sim_bm25, doc_recency, doc_categories):
label = rating2label(rating)
features = {
"origScore": "{:.5f}".format(orig_score),
"titleSimTFIDF": "{:.5f}".format(title_sim_tfidf),
"titleSimBM25": "{:.5f}".format(title_sim_bm25),
"descSimTFIDF": "{:.5f}".format(desc_sim_tfidf),
"descSimBM25": "{:.5f}".format(desc_sim_bm25),
"docRecency": "{:.5f}".format(doc_recency),
"isGoHands": "{:.3f}".format(doc_categories["isGoHands"]),
"isAniplex": "{:.3f}".format(doc_categories["isAniplex"]),
"isThriller": "{:.3f}".format(doc_categories["isThriller"]),
"isForeign": "{:.3f}".format(doc_categories["isForeign"]),
"isDrama": "{:.3f}".format(doc_categories["isDrama"]),
"isWar": "{:.3f}".format(doc_categories["isWar"]),
"isAction": "{:.3f}".format(doc_categories["isAction"]),
"isComedy": "{:.3f}".format(doc_categories["isComedy"]),
"isMusic": "{:.3f}".format(doc_categories["isMusic"]),
"isRomance": "{:.3f}".format(doc_categories["isRomance"]),
"isAdventure": "{:.3f}".format(doc_categories["isAdventure"]),
"isFamily": "{:.3f}".format(doc_categories["isFamily"]),
"isFantasy": "{:.3f}".format(doc_categories["isFantasy"]),
"isCrime": "{:.3f}".format(doc_categories["isCrime"]),
"isHorror": "{:.3f}".format(doc_categories["isHorror"]),
"isHistory": "{:.3f}".format(doc_categories["isHistory"]),
"isMystery": "{:.3f}".format(doc_categories["isMystery"]),
"isAnimation": "{:.3f}".format(doc_categories["isAnimation"]),
"isDocumentary": "{:.3f}".format(doc_categories["isDocumentary"]),
"isWestern": "{:.3f}".format(doc_categories["isWestern"])
}
feat_pairs = []
for feat_name in FEATURE_LIST:
feat_id = str(feature_name2id[feat_name])
feat_val = features[feat_name]
feat_pairs.append(":".join([feat_id, feat_val]))
return "{:d} qid:{:d} {:s} # docid:{:d} query:{:s}".format(
label, qid, " ".join(feat_pairs), doc_id, query)
random.shuffle(QUERY_LIST)
train_queries = QUERY_LIST[0:12]
val_queries = QUERY_LIST[12:15]
test_queries = QUERY_LIST[15:]
feat_suffixes = ["train", "val", "test"]
qid = 1
for qt_idx, queries in enumerate([train_queries, val_queries, test_queries]):
fletor = open(LETOR_FILE_TEMPLATE.format(feat_suffixes[qt_idx]), "w")
for query in queries:
print("generating feature for {:s} ({:s})".format(query, feat_suffixes[qt_idx]))
docs = get_search_results(query, 100)
# features from search result
orig_scores = [doc["score"] for doc in docs]
title_sims_tfidf = get_tfidf_similarities(query, docs, "title_t")
desc_sims_tfidf = get_tfidf_similarities(query, docs, "description_t")
title_sims_bm25 = get_bm25_similarities(query, docs, "title_t")
desc_sims_bm25 = get_bm25_similarities(query, docs, "description_t")
doc_recencies = get_doc_recencies(docs, "released_dt")
doc_categories = get_doc_categories(docs)
for i in range(len(docs)):
doc = docs[i]
# get additional fields
doc_id = int(doc["id"])
rating = doc["rating_f"]
# write record
fletor.write("{:s}\n".format(format_letor(doc_id, rating, qid, query, orig_scores[i],
title_sims_tfidf[i], desc_sims_tfidf[i],
title_sims_bm25[i], desc_sims_bm25[i],
doc_recencies[i], doc_categories[i])))
qid += 1
fletor.close()
print("number of queries, train {:d}, test {:d}, validation {:d}".format(
len(train_queries), len(test_queries), len(val_queries)))
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import numpy as np
import random
from sklearn.datasets.samples_generator import make_regression
import pylab
from scipy import stats
def gradient_descent_2(alpha, x, y, numIterations):
m = x.shape[0] # number of samples
theta = np.ones(2)
x_transpose = x.transpose()
for iter in range(0, numIterations):
hypothesis = np.dot(x, theta)
loss = hypothesis - y
J = np.sum(loss ** 2) / (2 * m) # cost
print ("iter %s | J: %.3f" % (iter, J) )
gradient = np.dot(x_transpose, loss) / m
theta = theta - alpha * gradient # update
return theta
if __name__ == '__main__':
x, y = make_regression(n_samples=100, n_features=1, n_informative=1,
random_state=0, noise=35)
m, n = np.shape(x)
x = np.c_[ np.ones(m), x] # insert column
alpha = 0.01 # learning rate
theta = gradient_descent_2(alpha, x, y, 1000)
# plot
for i in range(x.shape[1]):
y_predict = theta[0] + theta[1]*x
pylab.plot(x[:,1],y,'o')
pylab.plot(x,y_predict,'k-')
pylab.show()
print ("Done!")
# -
# y = mx + b where m is the slope and b is the y intercept that controls the bias.
#
# compute error for the given line and points
#
#
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Packages, Modules, Functions
import os
os.getcwd()
# Move your cursor the end of the below line and press tab.
os.
import pandas as pd
pd.DataFrame
type(pd)
import numpy as np
np.ascontiguousarray
np.array
df = pd.read_csv('../data/airlines.csv')
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important; }</style>"))
import pandas as pd
import numpy as np
import os
import re
import nltk
from nltk.stem import WordNetLemmatizer
from nltk.corpus import stopwords
import plotly.graph_objects as go
# -
path = "preprocess"
os.listdir(path)
df = pd.read_csv(os.path.join(path, 'usa.csv'))
print(df.shape)
df.head(1)
data = pd.DataFrame(df.groupby(["publish_year"])["abs"].count()).reset_index()
data["publish_year"] =data["publish_year"].astype(int)
data["abs"] =data["abs"].astype(int)
data.head(2)
# +
types = ['Korea', 'US']
# markers = ['circle', 'diamond', 'square', 'triangle-up', 'star', 'cross', 'x']
markers = ['circle', 'diamond']
# colors = ['#636EFA', '#EF553B', '#00CC96', '#AB63FA', '#FFA15A', '#19D3F3', '#FF6692']
colors = ['#636EFA', '#EF553B']
fig = go.Figure()
fig.add_trace(go.Scatter(x=data['publish_year'],
y=data['abs'],
mode = 'lines+markers',
name = "count",
line_shape='linear',
line=dict(color="#636EFA",
width=2,
# dash='line'
),
marker = dict(symbol="circle",
size=15),
),
)
fig.update_layout(
height = 400,
width = 800,
plot_bgcolor= "white",
font=dict(
# family="Courier New, monospace",
size=10,
color="black")
)
fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
fig.update_xaxes(showline=True, linewidth=1, linecolor='black', mirror=True, title='Year', tickmode = 'array', ticktext=[i for i in range(2001, 2021)], tickvals = [i for i in range(2001, 2021)], tickangle = 45)
fig.update_yaxes(showline=True, linewidth=1, linecolor='black', mirror=True, title='Count')
fig.update_layout(legend=dict(
orientation="h",
yanchor="bottom",
y=1.02,
xanchor="right",
x=0.98,
font=dict(
# family="Courier",
size=15,
color="black"
),
))
fig.show()
# +
nltk.download('punkt')
nltk.download('wordnet')
nltk.download('stopwords')
nltk.download('averaged_perceptron_tagger')
stop_words = list(set(stopwords.words('english')))
titled_stop_words = [w.title() for w in stop_words]
stop_words = stop_words + titled_stop_words
# +
def cleaning(t):
pattern = re.compile(r'[^a-zA-Z0-9]+')
result = re.sub(pattern, " ", str(t))
return result
def lemma(text):
n=WordNetLemmatizer()
result = []
for tok in text.split():
# tag_list=['v','n']
tag_list=['n']
res = nltk.pos_tag([tok])
tag = res[0][1][0].lower()
if tag not in tag_list:
# result.append(tok)
continue
result.append(n.lemmatize(tok, tag).strip())
return " ".join(result)
# -
df['text'] = df['title'] + ' ' + df['abs']
df.tail(1)
df['text'] = df['text'].str.lower()
df['text'] = df['text'].apply(cleaning)
df['text'] = df['text'].apply(lemma)
# 검색어
# 논문 빈춞 단어
# 지역명
user_stopwords = ['library', 'public',
'study','analysis','research','result','method','case', 'paper', 'survey', 'article', 'data', 'approach', "purpose",
'korea', 'korean', 'state']
df['text'] = df['text'].apply(lambda x : " ".join([w for w in x.split() if w not in stop_words]))
df['text'] = df['text'].apply(lambda x : " ".join([w for w in x.split() if w not in user_stopwords]))
all_words = df['text'].str.split(expand=True).unstack().value_counts()
all_words
words = pd.DataFrame(all_words).reset_index().rename(columns={'index':'word', 0: "CNT"})
low_freq_word = words[words['CNT']<(df.shape[0]/100)]['word'].tolist()
high_freq_word = ['service', 'information', 'user']
words.head(5)
df['text'] = df['text'].apply(lambda x : " ".join([w for w in x.split() if w not in low_freq_word]))
df['text'] = df['text'].apply(lambda x : " ".join([w for w in x.split() if w not in high_freq_word]))
processed_docs = df['text'].apply(lambda x : x.split())
# +
import gensim
from gensim import corpora
from gensim.models.ldamodel import LdaModel
from gensim.models.callbacks import CoherenceMetric , PerplexityMetric
from gensim.models.coherencemodel import CoherenceModel
from gensim.utils import simple_preprocess
from gensim.parsing.preprocessing import STOPWORDS
# Make dictionary
dictionary = gensim.corpora.Dictionary(processed_docs)
count = 0
print(len(dictionary))
# +
import matplotlib.pyplot as plt
def perplexity_coherence(bow_corpus, dictionary, processed_docs, st=2, en=16):
perplexity = []
coherence_socre = []
perplexity = []
coherence_socre = []
for i in range(st, en):
print(i, end=" ")
lda_model = gensim.models.LdaMulticore(bow_corpus, num_topics=i, id2word=dictionary, random_state=2021)
coherence_model_lda = CoherenceModel(model=lda_model, texts=processed_docs, dictionary=dictionary, coherence='c_v')
coherence_socre.append(coherence_model_lda.get_coherence())
perplexity.append(lda_model.log_perplexity(bow_corpus))
perplexity_change = []
for i, t in enumerate(perplexity[:-1]):
perplexity_change.append(perplexity[i+1] - perplexity[i])
fig, (ax1, ax3) = plt.subplots(1, 2, figsize=(25,8))
# fig.suptitle('Perplexity & Coherence Score')
ax1.plot(range(st, en), perplexity, 'bx-')
# ax2.plot(range(st+1, en), perplexity_change, 'bx-')
ax3.plot(range(st, en), coherence_socre, 'bx-')
ax1.grid(True)
# ax2.grid(True)
ax3.grid(True)
ax1.set_title("Perplexity", size=20)
ax3.set_title("Coherence Score", size=20)
ax1.tick_params(axis='x', labelsize=15)
ax3.tick_params(axis='x', labelsize=15)
ax1.tick_params(axis='y', labelsize=15)
ax3.tick_params(axis='y', labelsize=15)
# ax1.set_yticklabels (xlabels, fontsize =15)
fig.show()
# -
bow_corpus = [dictionary.doc2bow(doc) for doc in processed_docs]
# dictionary.filter_extremes(no_below=0.05, no_above=0.8, keep_n=100000)
# dictionary.filter_extremes(no_below=0.05)
len(dictionary)
perplexity_coherence(bow_corpus, dictionary, processed_docs, st=2, en=10)
lda_model = gensim.models.LdaMulticore(bow_corpus, num_topics=5, id2word=dictionary, random_state=2021)
lda_model.log_perplexity(bow_corpus)
coherence_model_lda = CoherenceModel(model=lda_model, texts=processed_docs, dictionary=dictionary, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()
coherence_lda
for idx, topic in lda_model.print_topics(-1):
print('Topic: {} \n Words: {}'.format(idx, topic))
def make_topictable_per_doc(ldamodel, corpus):
topic_table = pd.DataFrame()
# 몇 번째 문서인지를 의미하는 문서 번호와 해당 문서의 토픽 비중을 한 줄씩 꺼내온다.
for i, topic_list in enumerate(ldamodel[corpus]):
doc = topic_list[0] if ldamodel.per_word_topics else topic_list
doc = sorted(doc, key=lambda x: (x[1]), reverse=True)
# 각 문서에 대해서 비중이 높은 토픽순으로 토픽을 정렬한다.
# 모든 문서에 대해서 각각 아래를 수행
for j, (topic_num, prop_topic) in enumerate(doc): # 몇 번 토픽인지와 비중을 나눠서 저장한다.
if j == 0: # 정렬을 한 상태이므로 가장 앞에 있는 것이 가장 비중이 높은 토픽
topic_table = topic_table.append(pd.Series([int(topic_num), round(prop_topic,4), topic_list]), ignore_index=True)
# 가장 비중이 높은 토픽과, 가장 비중이 높은 토픽의 비중과, 전체 토픽의 비중을 저장한다.
else:
break
return(topic_table)
topictable = make_topictable_per_doc(lda_model, bow_corpus)
topictable = topictable.reset_index() # 문서 번호을 의미하는 열(column)로 사용하기 위해서 인덱스 열을 하나 더 만든다.
topictable.columns = ['index', 'topic', 'ratio', 'etc']
topictable[:10]
df = df.reset_index()
docs = df[['index', 'title', 'abs', 'publish_year']]
docs
topictable = topictable[['index', 'topic', 'ratio']]
docs = pd.merge(topictable, docs, on='index', how="inner")
docs['topic'] = docs['topic'] + 1
docs['topic'] = docs['topic'].astype(int)
docs['topic'] = "Topic-" + docs['topic'].astype(str)
docs
docs.groupby(['topic'])['index'].count()
def draw_line(data):
types = ['Topic-1', 'Topic-2', 'Topic-3','Topic-4','Topic-5']
# markers = ['circle', 'diamond', 'cross', 'x']
markers = ['circle', 'diamond', 'square', 'triangle-up', 'star']
# colors = ['#636EFA', '#EF553B', '#00CC96', '#AB63FA', '#FFA15A', '#19D3F3', '#FF6692']
colors = ['#636EFA', '#EF553B','#00CC96', '#AB63FA', '#FFA15A']
fig = go.Figure()
for t, m, c in zip(types, markers, colors):
temp = data[data['topic'] == t]
fig.add_trace(go.Scatter(x=temp['publish_year'],
y=temp['index'],
mode = 'lines+markers',
name = t,
line_shape='linear',
line=dict(color=c,
width=2,
# dash='line'
),
marker = dict(symbol=m,
size=15),
),
)
fig.update_layout(
height = 700,
width = 1100,
plot_bgcolor= "white",
font=dict(
# family="Courier New, monospace",
size=20,
color="black")
)
fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
fig.update_xaxes(showline=True, linewidth=1, linecolor='black', mirror=True, title='Year', tickmode = 'array', ticktext=[i for i in range(2001, 2021)], tickvals = [i for i in range(2001, 2021)], tickangle = 45)
fig.update_yaxes(showline=True, linewidth=1, linecolor='black', mirror=True, title='Count')
fig.update_layout(legend=dict(
orientation="h",
yanchor="bottom",
y=1.02,
xanchor="right",
x=0.98,
font=dict(
# family="Courier",
size=15,
color="black"
),
))
fig.show()
data = pd.DataFrame(docs.groupby(['topic', 'publish_year'])['index'].count()).reset_index()
draw_line(data)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# # Python Code Profilng
# ## Goal: Find all duplicates in 10,000 movie titles
# ! cat
def read_movies(filename:str) -> list:
"""Reads movie titles from a text file to a list of strings"""
with open(filename) as f:
movie_list = f.read().splitlines()
return movie_list
def is_duplicate(item:str, collection:list) -> bool:
"""Returns True if 'item' is in the list of movie titles"""
for movie in collection:
if movie.lower() == item.lower():
return True
return False
# +
## alternative
movie_list = [1, 5, 2, 1, 4, 5, 1]
movie_unique = set()
dup = {x for x in movie_list if x in movie_unique or (movie_unique.add(x) or False)}
print(dup) # {1, 5}
# -
@profile
def find_duplicate_movies(src='movies.txt') -> list:
"""Returns all duplicate movies."""
movie_list = read_movies(src)
duplicates = []
while movie_list:
movie = movie_list.pop(0)
if is_duplicate(movie, movie_list) and movie not in duplicates:
duplicates.append(movie)
return duplicates
m = read_movies('movies.txt')
len(m)
m[:3]
# %timeit is_duplicate('Scooby-Doo! Abracadabra-Doo (2010)', m)
dup = find_duplicate_movies() # super slow, this is bad, we need to profiling (analysing program for speed)
# +
# Measures
# time complexity
# space complexity
# -
# ---
# ### cProfile decorator:
# +
import cProfile, pstats, io
def profile(fnc):
"""A decorator that uses cProfile to profile a function.
Starts the profile before executing a function, then exeuctes the function,
then stops the profile, then prints out a diagnostics report.
Lots of boilerplate code from the Python 3 documentation:
https://docs.python.org/3/library/profile.html#profile.Profile
"""
def inner(*args, **kwargs):
pr = cProfile.Profile()
pr.enable()
retval = fnc(*args, **kwargs)
pr.disable()
s = io.StringIO()
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
ps.print_stats()
print(s.getvalue())
return retval
return inner
# -
# - Code / Example taken from Sebastian Mathot:
# - https://www.youtube.com/watch?v=8qEnExGLZfY
# - Adapted / annotated / slightly edited for live demo as part of Code Profiling lesson.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Deep Reinforcement Learning Beginners Tutorial (1) - Theory
# #### by Julian Bernhart, Robin Guth
# ## Table of contents
# 1. [Requirements](#requirements)
# 1. [Targets](#targets)
# 1. [Introduction](#introduction)
# 1. [Agents](#agent)
# 1. [Reinforcement Learning](#rl)
# 1. [The concept of RL](#conceptRL)
# 1. [Deep Learning Aspect](#dlaspect)
# 1. [Q-Learning](#qlearning)
# 1. [Outlook](#outlk)
# 1. [Sources](#source)
# ### Requirements: <a name="requirements"></a>
# - Basic knowledge about Artificial Intelligence
# - Basic understanding of deep learning
# - Knowledge regarding neural networks (NN)
# - (Optional) Knowledge regarding convolutional neural networks (CNN)
# ## Targets <a name="targets"></a>
#
# - introducing reinforcement learning
# - explaining components like agents, environments etc.
# - explaining Q-learning
# - explaining the use of deep learning in RL
# ## Introduction <a name="introduction"></a>
#
# In this notebook the reader is presented with the theory behind RL. After the completion, we will have a basic understanding of reinforcement learning (RL) and its components (Agent, Environment, Action, ...) as well as knowledge about the theory for the implementation of RL in the second notebook.
#
# Deep Reinforcement Learning (also called DRL) is a huge step towards the creation of an universal artificial intelligence. In 2013 a company, owned by Google, called ''Deep Mind'', was able to create an astonishing implementation of RL, which was capable to play retro games of the console ''Atari 2600''. In many cases, the AI (Artificial Intelligence) was not only able to play the games successfully, but also exceeded human performances significantly. After these impressive results, it is definitely worth to take a closer look at Reinforcement Learning.
#
# Playing games is fun, but reinforcement learning has more to offer, as discussed in [[3]](#sources) . Apart from playing video games, there are use cases in many fields like robotics, traffic control or even personalized advertisement. While supervised and unsupervised learning are already widely used in production, reinforcement learning is still in development and further research is needed.
# As a fairly new topic, beginners often struggle to find a good starting point into the world of AI and specifically RL. Many tutorials are written for more advanced users, who already have a deeper understanding of machine learning. The ''Deep Reinforcement Learning Beginners Tutorial" will provide an easy-to-follow, hands-on beginners guide to RL. After the completion, we will be able to write our own algorithm to play some basic games for us.
#
# Before we head into the world of reinforcement learning, we will have to talk about software agents.
# ### Agents <a name="agent"></a>
#
# The first component we will talk about are software agents. As described in [[1]](#sources), an agent is a program, which acts self-sufficient to solve a task. There are three important points, that an agent should fulfill:
#
# - autonomous action : an agent needs to make decisions without external help
# - proactivity: an agent needs to execute actions to complete its task
# - reactiv: an agent needs to react on changes in its environment
#
# Finally, there is one optional point:
#
# - ability to improve: an agent improves itself by building up knowledge after repetitively doing its task
#
# Basically, the part of the agent, which controls its actions, can be filled with different algorithms. In our case, this will be an implementation of RL, which fulfills all requirements of an agent.
# ## Reinforcement Learning <a name="rl"></a>
#
# Reinforcement Learning (RL) is considered one of the three machine learning paradigms, alongside supervised learning and unsupervised learning. The main goal of RL is to create an agent, which can navigate by actions in an environment in a way to maximize a representation of a cumulative reward. The environment is the space that contains the agent. We will talk about the environment later on. In order to maximize the reward, the agent has to learn by trial and error which actions most likely lead to a reward and which lead to a penalty. After some training, the agent will use its knowledge to avoid previous mistakes. It still has to explore the environment, because otherwise we can not be sure if we actually found the global maximum or just a local one and if there might be a better chain of actions. If we think about our real world example in [[3]](#sources), this method of learning is pretty close the human learning. If we get hurt for example, we are more likely to try to avoid the situation. Still, curiosity or necessity leads us to exploring and thus maybe getting us into danger, but in the best case, will lead us to some kind of positive reward.
#
# ### The concept of RL <a name="conceptRL"></a>
#
# Our agent is contained in an environment. A momentary snapshot of the environment is called state. A state contains all information at a certain point in time for example the position of the agent or enemies. There is a permanent exchange of information between the agent and its environment. The agent receives the actual state and has to choose an action based on its logic. Everything the agent can use to alter its environment is called an action. It changes the environment based on a certain set of rules. After executing an action the agents receives the new state and a reward, which helps to decide whether its decision leads to a positive result. Keep in mind, that a reward can also be negative. Basically, an environment is just a set of states. We can move between states by executing actions. A good example for an environment is our own world. We are agents, moving in the world. All the time we have to look at our surroundings and choose an action like moving across the street or waiting until it is free. The laws of physics restrain us, take gravity for example. We receive rewards like getting hurt or feeling satisfied, that is how we evaluate our actions. Our environment is constantly changing, so we have to reevaluate our decisions and choose an action again. The following picture shows the whole procedure:
#
# 
#
# Source: https://i.stack.imgur.com/eoeSq.png
#
# Our goal is to learn the best action for each state, so that our total reward reaches its global maximum.
#
# All components such as reward, amount and type of actions or states depend on the type of environment and can vary widely. As the real world example is pretty complex, for the rest of the notebook we will use a simple game environment for explanation. The information available for an agent are the visual output of the game (actual state), the input options and the reward for a previously taken action.
#
# The following diagram shows an exemplary setup for a RL project with a game as an _environment_. For the navigation through this environment the _agent_ needs the actual _state_ (game screen) as an input, in order to respond with an appropriate _action_. Every action taken leads to a value added to the score of the agent and a change in the environment resulting in the next state of the game.
#
# In order to improve its knowledge, the agent has to repeat the task multiple times. For this we define a set amount of epochs with a set amount of time for the agent to play.
#
# This is where the RL part comes into play. In order to maxmize the reward, the agent has to learn which actions result in a positive reward and should be preferred and which ones should be avoided because of a penalty. In the beginning, the agent has no knowledge about the environment and thus cannot make an educated decision. It will need to explore by taking random actions and observing the reward. These information will be added to the knowledge of the agent. Over time the agent needs to decrease the amount of explorational actions and increase the amount of exploitational action in order to progress. This means that the agent will start to decide on an action based on its gained knowledge, while decreasing the amount of random actions. A good decreasing ratio is very important for RL, as changing to fast will lead to bad results, while changing it to slow will lead to overfitting.
#
# 
#
# Source: https://medium.freecodecamp.org/an-introduction-to-reinforcement-learning-4339519de419
#
# #### Summary:
# - Agent: accepts states, executes actions
# - Environment: the world in which the agent exists and operates
# - Action ($A_{t}$): a move the agent can make in the environment
# - State ($S_{t}$): a situation which the agent perceives, a representation of the environment
# - Observation ($S_{t+1}$): the state of the environment after taking actions
# - Reward($R_{t}$): feedback that measures the success or failure of the agent's actions
# - Future Reward($R_{t+1}$): reward after taking actions
# ### Deep Learning Aspect <a name="dlaspect"></a>
#
# The agent has to recognize and differentiate elements in the environment, to be able to act accordingly and choose a proper action. In the best case, we already have the input reduced to some important numbers, which describe the actual state. In real applications this may not be possible or feasible with our knowledge. Most of the time we will have a picture available for example the image of a camera or a game screen, but the input we receive can basically be any sensory data.
#
# Furthermore, the agent must associate the occurrence of individual elements on screen with its own actions and the subsequent reward or penalty, which may occur only after several steps in the future. Depending on the situation it may be also necessary to estimate what the next state of the game could be. There are two possible ways to use the Deep Learning aspect.
#
# 1. Image processing with a Convolutional Neural Network (CNN), in order to process the image information and send this to the agent.
# 2. A Deep Q-Learning Network (DQN), in order to model the Q-function, which is discussed below.
#
# Following is an exemplary presentation of a neural network, which is designed according to the tasks just mentioned.
#
# 
#
# Source: https://zhuanlan.zhihu.com/p/25239682
# There are two ways to learn in deep reinforcement learning. Either we can use _Value Learning_ or _Policy Learning_. With value learning, we assign values to each state-action pair, which correspond to the probabilities of the pair being the best option. In policy learning, we will learn a strategy instead, which gives us the best estimated action for a given state s. In this notebook we will have a look at value learning.
# ### Q-Learning <a name="qlearning"></a>
#
# The task of the agent is the maximization of a cumulative future reward. An example of this can be the score in a game. In an environment, there is no guarantee for an immediate reward after executing an action. In many cases, only specific chains of actions lead to a positive reward, so the agent needs to learn multiple moves in succession in order to fulfill the given task. For example, if the agent needs to collect an object in order to get a higher score, it may be necessary to take multiple moves to reach it. The moves in between may not increase the reward significantly or even reduce it, however they are needed to complete the task in order to be successful.
#
# A simple way to implement RL is Q-Learning. We assign a numerical value to each action we can execute per state. This value is called Q-value. It represents an estimate of which action will result in the highest reward for the actual state. This is the knowledge of our agent. Each step we have to choose an action for the actual state. This is either random or knowledge based. We use random actions to explore our environment. If we use the knowledge of the agent, the next action is chosen by exploitation, so the agent uses the action with the highest Q-value for the given state.
#
# The Q-Values are not known at the beginning and need to be learned by training. For this purpose, the agent needs to explore its environment. In the best case, it will visit all states through every possible action, but most of the time, this is neither needed nor possible, because of the amount of states or actions. We only desire the path with the best overall reward. We have to keep in mind, that there is no guarantee, that a path we found is the global maximum. It is possible, that the agent is stuck at a local maximum and needs to sacrifice some reward to be able to reach a state with a bigger payout. The Q-values are initialized by $0$. After every step the agent takes, we need to update the last used Q-value according to the reward the agent receives. If the agent loses, dies or does something else we want to avoid, the resulting reward is negative. Either positive or negative, the Q-value needs to reflect this with its value. We need to update the Q-value regardless if the agent is exploring or exploiting. The exploration rate $\epsilon$ is slowly descending while training, so the agent can use its gained knowledge to improve the reward.
#
# In order to adjust the Q-values we need the _total reward_:
#
# >$R_t = \sum\limits_{i=t}^{\infty} r_i = r_t + r_{t+1} + ... + r_{t+n} + ...$
#
# The _total reward_ $R_t$ is the sum of the actual reward and all future rewards from actual state _t_ to state n = $\infty$.
#
# We also add a discount factor $\gamma$ to this formula. That factor has a range of value between/from $0$ to $1$ and is used to decrease rewards that are further into the future. This makes rewards in near future more decisive for the agent.
#
# >$R_t = \sum\limits_{i=t}^{\infty} \gamma _i r_i = \gamma _{t} r_t + \gamma _{t+1} r_{t+1} + ... + \gamma _{t+n} r_{t+n} + ...$
#
# The total reward $R_t$ is the discounted sum of future rewards.
#
#
# #### Q-function
#
# The Q-function is the name giving aspect of a Deep Q-Learning Network (DQN), while the "Q" stands for "Quality". The higher the reward, the higher the estimated Q-value and associated quality. This function represents the expected total future reward an agent could reach by executing a certain action $a_t$ in a given state $s_t$ and is used for our deep neural network. The DQN takes over the task of estimating this Q-value. With no prior information at the beginning, the agent needs to extend its knowledge by trial and error and thus learning, how to determine a Q-value out of the actual state and an action.
#
# >$<$Q-Value depending on $s$ and $a$ $> = <$Expected total future reward$>$
# <br>
# <br>
# $Q(s, a) = E[R_t]$
#
# If we have a good approximation of the Q-values for each state-action-pair after the exploration, the agent needs to decide on which action is the best for a given state. This means the agents needs to choose the action which maximizes the estimated future reward by the associated Q-value, with the help of a policy $\pi^*(s)$. This is the part of exploiting the gained knowledge.
#
# >$<$Optimal policy depending on $s$$> = <$Action resulting in the highest future reward according to current knowledge$>$
# <br>
# <br>
# $\pi^*(s) = {\underset{a}{\operatorname{argmax}}Q(s,a)}$
#
# Finally, we will take a look at the formula, which we will actually use to calculate Q-values. At the moment we use the current state of the environment, the actions to take and the reward, resulting from the decision of the agent as input. We also use the following state of the environment. We introduce the _Bellman equation_ now:
#
# >$<$Q-value depending on $s_t$ and $a_t$ $> = <$ Reward observed after the last action (immediate reward)$> + <$ Discount factor $> * <$ Maximum Q-value for the next state of the game (future reward)$>$
# <br>
# <br>
# $Q(s_t, a_t) = r_t + \gamma * \max\limits_{a'} Q(s', a')$
#
# For now the Bellman equation provides the Q-value for a given action in a given state. In order to train our DQN regarding the Q-function, it is necessary to compare the Q-values predicted with the actual ones and minimize the error between the two. If we use the Bellman equation to calculate this difference, by simply subtracting these values, we get the so called _temporal difference error_.
#
# >$<$Temporal difference error$> = <$ Target Q-value$> - <$ Predicted Q-value$>$
# <br>
# <br>
# $\delta = ( r_t + \gamma * \max\limits_{a'} Q(s', a')) - Q(s_t, a_t)$
#
# To update an old Q-value, we use the temporal difference error and add it to the Q-value. A new discount factor, called learning rate $\alpha$, determines the weight of the temporal difference error.
#
# >$<$new Q-value depending on $s_t$ and $a_t$ $> = <$old Q-value depending on $s_t$ and $a_t$ $> + <$Temporal difference error$>$
# <br>
# <br>
# $Q(s_t, a_t)_{new} = Q(s_t, a_t)_{old} + \alpha * \delta$
#
# Now we use _gradient descent_, an optimization algorithm, to optimize the Q-value approximation. Therefore we can train the DQN using _mean square error_ as the loss function, which results in the following formula.
#
# >$L = E[\lVert \delta \rVert ^2]$
#
# #### Model Q-function <a name="modellq"></a>
#
# The following illustration shows two options by which we can model our Q-function with a deep neural network. The model on the left side estimates one Q-value at the time. This is what we are using at the moment. The model on the right side is the preferred one, because it increases the efficiency. It gets the state of the environment and calculates multiple Q-values, so we just have to choose the highest value to determine the action for the agent instead of estimating the Q-values for every action individually. This will save processing power, as the amount of possible actions can be very large.
#
# 
# ## Outlook <a name="outlk"></a>
#
# In this notebook, we took a look at the basics of Reinforcement Learning. We talked about agents, environments and the relationship between the two. We introduced RL as a way to control an agent and explained two different approaches to implement RL with Q-learning. We took a deeper look at the Q-learning function and other components of an RL agent.
#
# We can now continue with the second notebook, there we will create our first agent with Python.
#
# As RL is a very complex topic, we recommend the reader to take a look at the sources or some of the following follow-up links for more in-depth information:
#
# https://www.youtube.com/watch?v=2pWv7GOvuf0 - full lecture series on RL from Google Deep Mind.
#
# https://www.youtube.com/watch?v=i6Mi2_QM3rA - full lecture on RL from MIT.
#
# # Sources <a name="source"></a>
#
# This notebook is based on the following tutorial:
#
# https://www.youtube.com/watch?v=i6Mi2_QM3rA - theory about DRL
#
# Further information was takenfrom the following articles/blogposts/tutorials:
#
# [1] https://wirtschaftslexikon.gabler.de/definition/agent-28615/version-252241 - definition of a software agent (german)
#
# [2] Playing Atari with Deep Reinforcement Learning; Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, Martin A. Riedmiller; 2013 - reinforcement learning with atari games
#
# [3] https://towardsdatascience.com/applications-of-reinforcement-learning-in-real-world-1a94955bcd12 - use cases for reinforcement learning
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # German Bank
# +
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# -
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, f_classif, chi2
from sklearn.model_selection import train_test_split
# %matplotlib inline
sns.set_theme()
# ## Load Data
# ### Features
#
# | 字段名 | 详细含义 |
# |:-------------------------------:|:-------------------------------------------------|
# |**Creditability** |是否有信用：1:有信用（即无违约用户），0:无信用（即违约用户）|
# |Account Balance |现存支票账户状态，1：月流水为0，2：月流水小于200马克，3：月流水大于等于200马克，4：未创建账户|
# |**Duration of Credit (month)** |贷款时长|
# |Payment Status of Previous Credit|历史信用情况。0：没有历史贷款或全部如期归还，1：在该银行的贷款已被全部归还，2：存在仍需还款的贷款，3：出现过延期归还情况，4：在其他银行仍存在贷款|
# |Purpose |贷款目的。0：汽车（新），1：汽车（二手），2：家具装备，3：广播设备电视，4：家用电器，5：维修需要，6：教育，7：度假，8：再培训深造，9：生意，10：其他|
# |**Credit Amount** |贷款金额|
# |Value Savings/Stocks |储蓄账户状态。1：储蓄金额小于100马克，2：储蓄金额大于等于100马克小于500马克，3：储蓄金额大于等于500马克小于1000马克，4：储蓄金额大于等于1000马克，5：未知或不存在储蓄账户|
# |Length of current employment |就职持续时间。1：暂无工作，2：就职小于1年，3：就职大于等于1年小于4年，4：就职大于等于4年小于7年，5：就职大于等于7年|
# |**Instalment per cent** |分期付款百分比|
# |Sex & Marital Status |性别与婚姻状况。1：男性离婚或分居，2：女性离婚、分居或已婚，3：男性单身，4：男性已婚或丧偶，5：女性单身|
# |Guarantors |担保人。1：无担保人，2：联保，3：有担保人|
# |**Duration in Current address** |当前住所的定居时间|
# |Most valuable available asset |最有价值的资产。1：房地产，2：社保或人寿保险，3：汽车或其他，4：未知或无财产|
# |**Age (years)** |年龄|
# |Concurrent Credits |其他分期付款情况。1：银行，2：商铺，3：无|
# |Type of apartment |住房类型。1：租赁，2：自己拥有，3：可免费居住|
# |**No of Credits at this Bank** |在这家银行的信用额度|
# |Occupation |职业。1：失业/非技术人员-非居民，2：非技术人员-居民，3：技术人员/官员，4：管理层/个体经营/高素质员工/管理人员|
# |**No of dependents** |供养人口数量|
# |Telephone |是否有以客户名称注册的电话.1：没有，2：有|
# |Foreign Worker |外籍工作者。1：是，2：不是|
#
qualitative_columns = [
# 'Creditability',
'Duration of Credit (month)',
'Credit Amount',
'Instalment per cent',
'Duration in Current address',
'Age (years)',
'No of Credits at this Bank',
'No of dependents',
]
quantitative_columns = [
'Account Balance',
'Payment Status of Previous Credit',
'Purpose',
'Value Savings/Stocks',
'Length of current employment',
'Sex & Marital Status',
'Guarantors',
'Most valuable available asset',
'Concurrent Credits',
'Type of apartment',
'Occupation',
'Telephone',
'Foreign Worker'
]
data = pd.read_excel("GermanBank.xlsx")
data
# ### Standarded Data
scaler = StandardScaler()
standard_data = data.copy()
standard_data[qualitative_columns] = pd.DataFrame(
scaler.fit_transform(data[qualitative_columns]),
columns=qualitative_columns
)
standard_data[qualitative_columns].describe()
standard_data.loc[standard_data['Foreign Worker'] == 2, 'Foreign Worker'] = 0
standard_data.loc[standard_data['Telephone'] == 1, 'Telephone'] = 0
standard_data.loc[standard_data['Telephone'] == 2, 'Telephone'] = 1
standard_data.to_excel("GermnnBank_Standard_Data.xlsx")
# ## Describe Data
data.info()
# ### Qualitative Search
data[qualitative_columns].describe().to_excel("qualitative_columns_describe.xlsx")
data[quantitative_columns].describe().to_excel("quantitative_columns_describe.xlsx")
data.corr()['Creditability'].abs() > 0.2
features_chi2[0]
# ### Quantitative Search
for label in quantitative_columns:
print(data[label].value_counts().sort_values(ascending=False))
print("-" * 32)
data_male = data[data['Sex & Marital Status'].isin([1, 3, 4])]
data_female = data[data['Sex & Marital Status'].isin([2, 5])]
data_male
# ## Analysis Data
fig, ax = plt.subplots(figsize=(9, 6))
sns.heatmap(data[data.columns.difference(['Sex & Marital Status'])].corr())
# ## Classification
# ### Select features
features = standard_data[standard_data.columns.difference(['Creditability'])]
# features_quantitative = standard_data[quantitative_columns]
labels = standard_data['Creditability']
features_chi2 = SelectKBest(chi2, k=15).fit_transform(
data[data.columns.difference(['Creditability'])],
data['Creditability'],
)
from sklearn.decomposition import PCA
PCA.
# ### SVM
from sklearn import svm
x_train, x_test, y_train, y_test = train_test_split(
features, labels, test_size=0.4, random_state=0, shuffle=True
)
clf = svm.SVC(
kernel='rbf',
decision_function_shape='ovo'
)
# +
clf.fit(
x_train,
y_train
)
y_pred = clf.predict(x_test)
# -
from sklearn import metrics
fpr, tpr, thresholds = metrics.roc_curve(y_test.to_numpy(), y_pred)
tpr
fpr
# +
fig, ax = plt.subplots()
ax.plot(fpr, tpr)
# -
clf.get_params()
# ### BPN
# +
import torch
import torch.nn as nn
import torch.nn.functional as Fun
class Net(torch.nn.Module):
def __init__(self, n_feature, n_output):
super(Net, self).__init__()
self.hidden1 = torch.nn.Linear(n_feature, 15)
self.hidden2 = torch.nn.Linear(15, 15)
self.hidden3 = torch.nn.Linear(15, 8)
self.out = torch.nn.Linear(8, n_output)
def forward(self, x):
x = Fun.relu(self.hidden1(x))
x = Fun.relu(self.hidden2(x))
x = Fun.relu(self.hidden3(x))
x = self.out(x)
return x
# -
x_train, x_test, y_train, y_test = train_test_split(
features, labels, test_size=0.2, random_state=0, shuffle=True
)
features_nn = torch.FloatTensor(x_train.to_numpy())
label_nn = torch.LongTensor(y_train.to_numpy())
net = Net(20, 2)
optimizer = torch.optim.SGD(net.parameters(), lr=0.05)
loss_func = torch.nn.CrossEntropyLoss()
for i in range(1000):
out = net(features_nn)
# print(f"{out[:, 0]=}")
# print(f"{label_nn.shape=}")
loss = loss_func(out, label_nn)
optimizer.zero_grad()
loss.backward()
optimizer.step()
out = net(torch.FloatTensor(x_test.to_numpy()))
prediction = torch.max(out, 1)[1]
pred_y = prediction.numpy()
pred_y
1. - np.sum(np.abs(pred_y - y_test)) / y_test.size
fpr, tpr, thresholds = metrics.roc_curve(y_test.to_numpy(), pred_y)
fpr
tpr
# +
fig, ax = plt.subplots()
ax.plot(fpr, tpr)
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# <font size="+5">#04 | Transforming Basic Objects into the Powerful DataFrame</font>
# - <ins>Python</ins> + <ins>Data Science</ins> Tutorials in [YouTube ↗︎](https://www.youtube.com/c/PythonResolver)
# ## All that glitters is not gold
#
# > - Not all objects can call the same functions
# > - Even though they may store the same information
# ### `list`
# > - Create a list with your math `grades`
lista_notas = [10, 7, 8]
# > - Compute the mean
lista_notas.mean()
# > - You cannot do the mean
# > - But you could `sum()` and `len()`
sum(lista_notas)
len(lista_notas)
# > - And divide the sum by the number of exams you did
sum(lista_notas)/len(lista_notas)
# > - [ ] Isn't it an `object` that could calculate the `mean()`?
# ### `Series`
import pandas as pd
series_notas = pd.Series([10, 7, 8])
series_notas
series_notas.mean()
lista_notas
lista_notas.mean()
type(notas_series)
type(notas)
# > - Use the `.` + `[tab]` key to see the `functions/methods` of the object
notas.
series_notas.
# ## Store the information in Python `objects` for the Best Tennis Players
# > - income
# > - titles
# > - grand slams
# > - turned professional
# > - wins
# > - losses
# ### Create a `dictionary` for Roger Federer
roger = {'income': 130, 'titles': 103, 'grand slams': 20, 'turned professional': 1998, 'wins': 1251, 'losses': 275}
roger
# + [markdown] tags=[]
# ### Create a `dictionary` for Rafa Nadal
# -
rafa = {'income': 127, 'titles': 90, 'grand slams': 21, 'turned professional': 2001, 'wins': 1038, 'losses': 209}
rafa
# ### Create a `dictionary` for Novak Djokovic
nole = {'income': 154, 'titles': 86, 'grand slams': 20, 'turned professional': 2003, 'wins': 989, 'losses': 199}
nole
# ### How much wealth did all of them earned?
# > - You may put all of them into a `list`
# > - And `sum()` the `income`
lista_best_players = [roger, rafa, nole] # se queda
lista_best_players
lista_best_players.sum()
# > - The `sum()` is not an action
# > - that a simple object `list` can perform
# > - [ ] Could we convert the list into a
# > - more powerful object
# > - that could compute the `sum()`?
import pandas as pd
pd.DataFrame(lista_best_players)
df_best_players = pd.DataFrame(lista_best_players, index=['Roger Federer', 'Rafa Nadal', 'Novak Djokovic'])
df_best_players
# > - Access the `income` column
# > - and compute the `sum()`
df_best_players['income']
df_best_players['income'].sum()
# > - [ ] Which type of `object` is the table?
type(df_best_players)
# > - [ ] What else can we do with this `object`?
df_best_players.
# ## Can we select specific parts of the `DataFrame`?
# > - Remember that an `object` is a **structure of data**
# > - In other words, it may contain **more objects**
# ### Names of rows `index`
df_best_players.index
# ### Names of `columns`
df_best_players.columns
# > Number of rows & columns `shape`
df_best_players.shape
# ## Read data from a file
df = pd.read_json('https://raw.githubusercontent.com/jsulopz/data/main/football_players_stats.json')
df = df.transpose()
df.goles/df.partidos
res = df.goles/df.partidos
res.sort_values(ascending=False)
res.sort_values(ascending=False).plot(kind='bar')
df
pd.read_html(io='https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_population')[0]
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] papermill={"duration": 0.061517, "end_time": "2021-09-26T12:39:07.329190", "exception": false, "start_time": "2021-09-26T12:39:07.267673", "status": "completed"} tags=[]
# <h1 style='text-align: center'>Raifhack-DS-2021-Fall 👽</h1>
#
# <p style='text-align: center'>
# This notebook is in <span style='color: green; font-weight: 700'>Active</span> state of development! Check out this notebook to see some updates as I update new stuff as oftern as I learn it!
# <a style='font-weight:700' href='https://github.com/LilDataScientist/Raifhack-DS-2021-Fall'> Code on GitHub! </a></p>
# + [markdown] papermill={"duration": 0.056591, "end_time": "2021-09-26T12:39:07.443851", "exception": false, "start_time": "2021-09-26T12:39:07.387260", "status": "completed"} tags=[]
# <div style='text-align: center'>
# <img src='https://i.postimg.cc/HLF8SsJK/B041-Bank-of-the-West.jpg' width='700' />
# </div>
# + _cell_guid="b1076dfc-b9ad-4769-8c92-a6c4dae69d19" _kg_hide-input=false _uuid="8f2839f25d086af736a60e9eeb907d3b93b6e0e5" papermill={"duration": 1.201297, "end_time": "2021-09-26T12:39:08.702703", "exception": false, "start_time": "2021-09-26T12:39:07.501406", "status": "completed"} tags=[]
import numpy as np
import pandas as pd
# Visualization
import seaborn as sns
import matplotlib.pyplot as plt
import missingno as msno
# Models
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
# Pipelines
from sklearn.pipeline import Pipeline, FeatureUnion
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder
from sklearn.compose import ColumnTransformer
# Helpers
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.metrics import accuracy_score, mean_squared_error, make_scorer, mean_absolute_error
sns.set_theme()
# + _kg_hide-input=false papermill={"duration": 4.939258, "end_time": "2021-09-26T12:39:13.703120", "exception": false, "start_time": "2021-09-26T12:39:08.763862", "status": "completed"} tags=[]
df_train = pd.read_csv('../input/raifhackds2021fall/data/train.csv')
# + [markdown] papermill={"duration": 0.057609, "end_time": "2021-09-26T12:39:13.819286", "exception": false, "start_time": "2021-09-26T12:39:13.761677", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Quick view</h1>
# + _kg_hide-input=false papermill={"duration": 0.208645, "end_time": "2021-09-26T12:39:14.086040", "exception": false, "start_time": "2021-09-26T12:39:13.877395", "status": "completed"} tags=[]
df_train
# + [markdown] papermill={"duration": 0.059093, "end_time": "2021-09-26T12:39:14.204978", "exception": false, "start_time": "2021-09-26T12:39:14.145885", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Describe data</h1>
# + _kg_hide-input=false papermill={"duration": 0.825708, "end_time": "2021-09-26T12:39:15.089409", "exception": false, "start_time": "2021-09-26T12:39:14.263701", "status": "completed"} tags=[]
df_train.describe()
# + [markdown] papermill={"duration": 0.058963, "end_time": "2021-09-26T12:39:15.208596", "exception": false, "start_time": "2021-09-26T12:39:15.149633", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Missing values</h1>
# + _kg_hide-input=false papermill={"duration": 0.069734, "end_time": "2021-09-26T12:39:15.337626", "exception": false, "start_time": "2021-09-26T12:39:15.267892", "status": "completed"} tags=[]
def print_missing_values(df):
missing_values_df = pd.DataFrame(columns=['dtype','Feature', 'Number Of Missing Values', 'Percentage of Missing values'])
for i in df:
if df[i].isnull().sum() != 0:
dtype = df[i].dtype
feature = i
number_of_missing_values = df[i].isnull().sum()
percentage_of_missing_values = round(number_of_missing_values / len(df.index) * 100, 2)
missing_values_df = missing_values_df.append({
'dtype': dtype,
'Feature': i,
'Number Of Missing Values': number_of_missing_values,
'Percentage of Missing values': percentage_of_missing_values
}, ignore_index=True)
return missing_values_df
# + papermill={"duration": 0.390349, "end_time": "2021-09-26T12:39:15.787581", "exception": false, "start_time": "2021-09-26T12:39:15.397232", "status": "completed"} tags=[]
print_missing_values(df_train)
# + [markdown] papermill={"duration": 0.059873, "end_time": "2021-09-26T12:39:15.908369", "exception": false, "start_time": "2021-09-26T12:39:15.848496", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Unique values</h1>
# + papermill={"duration": 0.070607, "end_time": "2021-09-26T12:39:16.039070", "exception": false, "start_time": "2021-09-26T12:39:15.968463", "status": "completed"} tags=[]
def print_unique_values(df):
unique_values_df = pd.DataFrame(columns=['Feature', 'Number of values', 'Values'])
for col in df:
unique_values_df = unique_values_df.append({
'Feature': col,
'Number of values': df[col].unique().shape[0],
'Values': df[col].unique()
}, ignore_index=True)
pd.set_option('display.max_rows', len(unique_values_df))
return unique_values_df
# + papermill={"duration": 1.315983, "end_time": "2021-09-26T12:39:17.415489", "exception": false, "start_time": "2021-09-26T12:39:16.099506", "status": "completed"} tags=[]
print_unique_values(df_train)
# + papermill={"duration": 0.138408, "end_time": "2021-09-26T12:39:17.622913", "exception": false, "start_time": "2021-09-26T12:39:17.484505", "status": "completed"} tags=[]
ID = df_train['id']
df_train.drop(['id', 'lat', 'lng', 'osm_city_nearest_name', 'date', 'street', 'floor', 'osm_city_closest_dist'], axis=1, inplace=True)
# + papermill={"duration": 0.841897, "end_time": "2021-09-26T12:39:18.526717", "exception": false, "start_time": "2021-09-26T12:39:17.684820", "status": "completed"} tags=[]
print_unique_values(df_train)
# + [markdown] papermill={"duration": 0.063446, "end_time": "2021-09-26T12:39:18.655899", "exception": false, "start_time": "2021-09-26T12:39:18.592453", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Location [Feature engineering]</h1>
# + _kg_hide-input=false papermill={"duration": 0.774554, "end_time": "2021-09-26T12:39:19.493262", "exception": false, "start_time": "2021-09-26T12:39:18.718708", "status": "completed"} tags=[]
def location(df):
is_moscow = []
is_moscow_oblast = []
is_region = []
for row in df['region']:
if row == 'Москва':
is_moscow.append(1)
is_moscow_oblast.append(0)
is_region.append(0)
elif row == 'Московская область':
is_moscow.append(0)
is_moscow_oblast.append(1)
is_region.append(0)
else:
is_moscow.append(0)
is_moscow_oblast.append(0)
is_region.append(1)
df['is_moscow'] = is_moscow
df['is_moscow_oblast'] = is_moscow_oblast
df['is_region'] = is_region
df.drop(['region'], axis=1, inplace=True)
print('Moscow: ' + str((len(df[df['is_moscow'] == 1]))))
print('Moscow oblast: ' + str((len(df[df['is_moscow_oblast'] == 1]))))
print('Region: ' + str((len(df[df['is_region'] == 1]))))
location(df_train)
# + [markdown] papermill={"duration": 0.073547, "end_time": "2021-09-26T12:39:19.630208", "exception": false, "start_time": "2021-09-26T12:39:19.556661", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>CIies with > 1M people [Feature engineering]</h1>
# + _kg_hide-input=false papermill={"duration": 0.668714, "end_time": "2021-09-26T12:39:20.378828", "exception": false, "start_time": "2021-09-26T12:39:19.710114", "status": "completed"} tags=[]
def cities_1m(df):
cities_1m_people = ['Москва', 'Санкт-Петербург', 'Новосибирск', 'Екатеринбург', 'Казань', 'Нижний Новгород', 'Челябинск', 'Самара', 'Омск',
'Ростов-на-Дону', 'Уфа', 'Красноярск', 'Воронеж', 'Пермь', 'Волгоград']
is_million = []
is_not_million = []
for row in df['city']:
if row in cities_1m_people:
is_million.append(1)
is_not_million.append(0)
else:
is_million.append(0)
is_not_million.append(1)
df['is_million'] = is_million
df['is_not_million'] = is_not_million
df.drop(['city'], axis=1, inplace=True)
print('is_million: ' + str((len(df[df['is_million'] == 1]))))
print('is_not_million: ' + str((len(df[df['is_not_million'] == 1]))))
cities_1m(df_train)
# + [markdown] papermill={"duration": 0.062878, "end_time": "2021-09-26T12:39:20.504965", "exception": false, "start_time": "2021-09-26T12:39:20.442087", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>District rate [Feature engineering]</h1>
# + papermill={"duration": 0.422895, "end_time": "2021-09-26T12:39:20.991613", "exception": false, "start_time": "2021-09-26T12:39:20.568718", "status": "completed"} tags=[]
def make_district(df):
district_rate = []
for row in df['realty_type']:
if row == 110:
district_rate.append(1)
elif row == 100:
district_rate.append(10)
elif row == 10:
district_rate.append(0)
df['district_rate'] = district_rate
df.drop(['realty_type'], axis=1, inplace=True)
make_district(df_train)
# + [markdown] papermill={"duration": 0.064145, "end_time": "2021-09-26T12:39:21.119394", "exception": false, "start_time": "2021-09-26T12:39:21.055249", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Offices [Feature engineering]</h1>
# + papermill={"duration": 9.054019, "end_time": "2021-09-26T12:39:30.238722", "exception": false, "start_time": "2021-09-26T12:39:21.184703", "status": "completed"} tags=[]
def offices(df):
many_offices = []
for i in range(len(df['osm_offices_points_in_0.001'])):
if df['osm_offices_points_in_0.001'][i] > 2 or df['osm_offices_points_in_0.005'][i] > 10 or df['osm_offices_points_in_0.0075'][i] > 15 or df['osm_offices_points_in_0.01'][i] > 20:
many_offices.append(1)
else:
many_offices.append(0)
df['many_offices'] = many_offices
df.drop(['osm_offices_points_in_0.001', 'osm_offices_points_in_0.005', 'osm_offices_points_in_0.0075', 'osm_offices_points_in_0.01'], axis=1, inplace=True)
offices(df_train)
# + [markdown] papermill={"duration": 0.062932, "end_time": "2021-09-26T12:39:30.365049", "exception": false, "start_time": "2021-09-26T12:39:30.302117", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Food [Feature engineering]</h1>
# + papermill={"duration": 8.333311, "end_time": "2021-09-26T12:39:38.761616", "exception": false, "start_time": "2021-09-26T12:39:30.428305", "status": "completed"} tags=[]
def food(df):
many_food = []
for i in range(len(df['osm_catering_points_in_0.001'])):
if df['osm_catering_points_in_0.001'][i] > 2 or df['osm_catering_points_in_0.005'][i] > 10 or df['osm_catering_points_in_0.0075'][i] > 15 or df['osm_catering_points_in_0.01'][i] > 20:
many_food.append(1)
else:
many_food.append(0)
df['many_food'] = many_food
df.drop(['osm_catering_points_in_0.001', 'osm_catering_points_in_0.005', 'osm_catering_points_in_0.0075', 'osm_catering_points_in_0.01'], axis=1, inplace=True)
food(df_train)
# + [markdown] papermill={"duration": 0.064014, "end_time": "2021-09-26T12:39:38.889263", "exception": false, "start_time": "2021-09-26T12:39:38.825249", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Shops [Feature engineering]</h1>
# + papermill={"duration": 6.221261, "end_time": "2021-09-26T12:39:45.174362", "exception": false, "start_time": "2021-09-26T12:39:38.953101", "status": "completed"} tags=[]
def shops(df):
many_shops = []
for i in range(len(df['osm_shops_points_in_0.001'])):
if df['osm_shops_points_in_0.001'][i] > 2 or df['osm_shops_points_in_0.005'][i] > 10 or df['osm_shops_points_in_0.0075'][i] > 15 or df['osm_shops_points_in_0.01'][i] > 20:
many_shops.append(1)
else:
many_shops.append(0)
df['many_shops'] = many_shops
df.drop(['osm_shops_points_in_0.001', 'osm_shops_points_in_0.005', 'osm_shops_points_in_0.0075', 'osm_shops_points_in_0.01'], axis=1, inplace=True)
shops(df_train)
# + [markdown] papermill={"duration": 0.063317, "end_time": "2021-09-26T12:39:45.301043", "exception": false, "start_time": "2021-09-26T12:39:45.237726", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>>Financial Organizations [Feature engineering]</h1>
# + papermill={"duration": 9.218105, "end_time": "2021-09-26T12:39:54.582948", "exception": false, "start_time": "2021-09-26T12:39:45.364843", "status": "completed"} tags=[]
def financial_organizations(df):
many_financial_organizations = []
for i in range(len(df['osm_finance_points_in_0.001'])):
if df['osm_finance_points_in_0.001'][i] > 2 or df['osm_finance_points_in_0.005'][i] > 10 or df['osm_finance_points_in_0.0075'][i] > 15 or df['osm_finance_points_in_0.01'][i] > 20:
many_financial_organizations.append(1)
else:
many_financial_organizations.append(0)
df['many_financial_organizations'] = many_financial_organizations
df.drop(['osm_finance_points_in_0.001', 'osm_finance_points_in_0.005', 'osm_finance_points_in_0.0075', 'osm_finance_points_in_0.01'], axis=1, inplace=True)
financial_organizations(df_train)
# + [markdown] papermill={"duration": 0.063187, "end_time": "2021-09-26T12:39:54.711616", "exception": false, "start_time": "2021-09-26T12:39:54.648429", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Medicine [Feature engineering]</h1>
# + papermill={"duration": 5.061811, "end_time": "2021-09-26T12:39:59.836933", "exception": false, "start_time": "2021-09-26T12:39:54.775122", "status": "completed"} tags=[]
def medecine(df):
many_medicine = []
for i in range(len(df['osm_healthcare_points_in_0.005'])):
if df['osm_healthcare_points_in_0.005'][i] > 1 or df['osm_healthcare_points_in_0.0075'][i] > 1 or df['osm_healthcare_points_in_0.01'][i] > 1:
many_medicine.append(1)
else:
many_medicine.append(0)
df['many_medicine'] = many_medicine
df.drop(['osm_healthcare_points_in_0.005', 'osm_healthcare_points_in_0.0075', 'osm_healthcare_points_in_0.01'], axis=1, inplace=True)
medecine(df_train)
# + [markdown] papermill={"duration": 0.062713, "end_time": "2021-09-26T12:39:59.962978", "exception": false, "start_time": "2021-09-26T12:39:59.900265", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Entertainment [Feature engineering]</h1>
# + papermill={"duration": 5.422054, "end_time": "2021-09-26T12:40:05.448710", "exception": false, "start_time": "2021-09-26T12:40:00.026656", "status": "completed"} tags=[]
def entertainment(df):
many_entertainment = []
for i in range(len(df['osm_leisure_points_in_0.005'])):
if df['osm_leisure_points_in_0.005'][i] > 1 or df['osm_leisure_points_in_0.0075'][i] > 3 or df['osm_leisure_points_in_0.01'][i] > 1:
many_entertainment.append(1)
else:
many_entertainment.append(0)
df['many_entertainment'] = many_entertainment
df.drop(['osm_leisure_points_in_0.005', 'osm_leisure_points_in_0.0075', 'osm_leisure_points_in_0.01'], axis=1, inplace=True)
entertainment(df_train)
# + [markdown] papermill={"duration": 0.065442, "end_time": "2021-09-26T12:40:05.577972", "exception": false, "start_time": "2021-09-26T12:40:05.512530", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Historical objects [Feature engineering]</h1>
# + papermill={"duration": 5.933562, "end_time": "2021-09-26T12:40:11.575301", "exception": false, "start_time": "2021-09-26T12:40:05.641739", "status": "completed"} tags=[]
def hist_obj(df):
many_historical_objects = []
for i in range(len(df['osm_historic_points_in_0.005'])):
if df['osm_historic_points_in_0.005'][i] > 1 or df['osm_historic_points_in_0.0075'][i] > 3 or df['osm_historic_points_in_0.01'][i] > 1:
many_historical_objects.append(1)
else:
many_historical_objects.append(0)
df['many_historical_objects'] = many_historical_objects
df.drop(['osm_historic_points_in_0.005', 'osm_historic_points_in_0.0075', 'osm_historic_points_in_0.01'], axis=1, inplace=True)
hist_obj(df_train)
# + [markdown] papermill={"duration": 0.063715, "end_time": "2021-09-26T12:40:11.703433", "exception": false, "start_time": "2021-09-26T12:40:11.639718", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Buildings [Feature engineering]</h1>
# + papermill={"duration": 4.900104, "end_time": "2021-09-26T12:40:16.667067", "exception": false, "start_time": "2021-09-26T12:40:11.766963", "status": "completed"} tags=[]
def buildings(df):
many_buildings = []
for i in range(len(df['osm_building_points_in_0.001'])):
if df['osm_building_points_in_0.001'][i] > 2 or df['osm_building_points_in_0.005'][i] > 5:
many_buildings.append(1)
else:
many_buildings.append(0)
df['many_buildings'] = many_buildings
df.drop(['osm_building_points_in_0.001', 'osm_building_points_in_0.005'], axis=1, inplace=True)
buildings(df_train)
# + papermill={"duration": 0.600341, "end_time": "2021-09-26T12:40:17.334430", "exception": false, "start_time": "2021-09-26T12:40:16.734089", "status": "completed"} tags=[]
print_unique_values(df_train)
# + [markdown] papermill={"duration": 0.0638, "end_time": "2021-09-26T12:40:17.462505", "exception": false, "start_time": "2021-09-26T12:40:17.398705", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Hotels [Feature engineering]</h1>
# + papermill={"duration": 6.291024, "end_time": "2021-09-26T12:40:23.817809", "exception": false, "start_time": "2021-09-26T12:40:17.526785", "status": "completed"} tags=[]
def hotels(df):
many_hotels = []
for i in range(len(df['osm_hotels_points_in_0.005'])):
if df['osm_hotels_points_in_0.005'][i] > 1 or df['osm_hotels_points_in_0.0075'][i] > 1 or df['osm_hotels_points_in_0.01'][i] > 1:
many_hotels.append(1)
else:
many_hotels.append(0)
df['many_hotels'] = many_hotels
df.drop(['osm_hotels_points_in_0.005', 'osm_hotels_points_in_0.0075', 'osm_hotels_points_in_0.01'], axis=1, inplace=True)
hotels(df_train)
# + [markdown] papermill={"duration": 0.064273, "end_time": "2021-09-26T12:40:23.946611", "exception": false, "start_time": "2021-09-26T12:40:23.882338", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Station score [Feature engineering]</h1>
# + papermill={"duration": 0.398172, "end_time": "2021-09-26T12:40:24.409367", "exception": false, "start_time": "2021-09-26T12:40:24.011195", "status": "completed"} tags=[]
def stations_score(df):
station_rate = []
for row in df['osm_train_stop_closest_dist']:
if row > 4:
station_rate.append(0)
elif row <= 4 and row > 1:
station_rate.append(5)
else:
station_rate.append(1)
df['station_rate'] = station_rate
df.drop(['osm_train_stop_closest_dist'], axis=1, inplace=True)
stations_score(df_train)
# + [markdown] papermill={"duration": 0.064704, "end_time": "2021-09-26T12:40:24.538941", "exception": false, "start_time": "2021-09-26T12:40:24.474237", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Stations [Feature engineering]</h1>
# + papermill={"duration": 7.064523, "end_time": "2021-09-26T12:40:31.670224", "exception": false, "start_time": "2021-09-26T12:40:24.605701", "status": "completed"} tags=[]
def stations(df):
many_stations = []
for i in range(len(df['osm_train_stop_points_in_0.005'])):
if df['osm_train_stop_points_in_0.005'][i] > 1 or df['osm_train_stop_points_in_0.0075'][i] > 1 or df['osm_train_stop_points_in_0.01'][i] > 1:
many_stations.append(1)
else:
many_stations.append(0)
df['many_stations'] = many_stations
df.drop(['osm_train_stop_points_in_0.005', 'osm_train_stop_points_in_0.0075', 'osm_train_stop_points_in_0.01'], axis=1, inplace=True)
stations(df_train)
# + [markdown] papermill={"duration": 0.065215, "end_time": "2021-09-26T12:40:31.800375", "exception": false, "start_time": "2021-09-26T12:40:31.735160", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Land transport [Feature engineering]</h1>
# + papermill={"duration": 3.331313, "end_time": "2021-09-26T12:40:35.196243", "exception": false, "start_time": "2021-09-26T12:40:31.864930", "status": "completed"} tags=[]
def land_transport(df):
many_land_transport = []
for i in range(len(df['osm_transport_stop_points_in_0.005'])):
if df['osm_transport_stop_points_in_0.005'][i] > 1 or df['osm_transport_stop_points_in_0.0075'][i] > 1 or df['osm_transport_stop_points_in_0.01'][i] > 1:
many_land_transport.append(1)
else:
many_land_transport.append(0)
df['many_land_transport'] = many_land_transport
df.drop(['osm_transport_stop_points_in_0.005', 'osm_transport_stop_points_in_0.0075', 'osm_transport_stop_points_in_0.01',
'osm_transport_stop_closest_dist', 'osm_subway_closest_dist'], axis=1, inplace=True)
land_transport(df_train)
# + [markdown] papermill={"duration": 0.063697, "end_time": "2021-09-26T12:40:35.323858", "exception": false, "start_time": "2021-09-26T12:40:35.260161", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Pedestrian crossings [Feature engineering]</h1>
# + papermill={"duration": 5.260887, "end_time": "2021-09-26T12:40:40.648709", "exception": false, "start_time": "2021-09-26T12:40:35.387822", "status": "completed"} tags=[]
def pedestrian_crossings(df):
many_pedestrian_crossings = []
for i in range(len(df['osm_crossing_points_in_0.001'])):
if df['osm_crossing_points_in_0.001'][i] > 1 or df['osm_crossing_points_in_0.005'][i] > 1 or df['osm_crossing_points_in_0.0075'][i] > 1 or df['osm_crossing_points_in_0.01'][i]:
many_pedestrian_crossings.append(1)
else:
many_pedestrian_crossings.append(0)
df['many_pedestrian_crossings'] = many_pedestrian_crossings
df.drop(['osm_crossing_points_in_0.001', 'osm_crossing_points_in_0.005', 'osm_crossing_points_in_0.0075', 'osm_crossing_points_in_0.01',
'osm_crossing_closest_dist'], axis=1, inplace=True)
pedestrian_crossings(df_train)
# + [markdown] papermill={"duration": 0.064035, "end_time": "2021-09-26T12:40:40.778078", "exception": false, "start_time": "2021-09-26T12:40:40.714043", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Culture objects [Feature engineering]</h1>
# + papermill={"duration": 8.194042, "end_time": "2021-09-26T12:40:49.036456", "exception": false, "start_time": "2021-09-26T12:40:40.842414", "status": "completed"} tags=[]
def culture_objects(df):
many_culture_objects = []
for i in range(len(df['osm_culture_points_in_0.001'])):
if df['osm_culture_points_in_0.001'][i] > 1 or df['osm_culture_points_in_0.005'][i] > 1 or df['osm_culture_points_in_0.0075'][i] > 1 or df['osm_culture_points_in_0.01'][i] > 1:
many_culture_objects.append(1)
else:
many_culture_objects.append(0)
df['many_culture_objects'] = many_culture_objects
df.drop(['osm_culture_points_in_0.001', 'osm_culture_points_in_0.005', 'osm_culture_points_in_0.0075', 'osm_culture_points_in_0.01'], axis=1, inplace=True)
culture_objects(df_train)
# + [markdown] papermill={"duration": 0.065964, "end_time": "2021-09-26T12:40:49.168706", "exception": false, "start_time": "2021-09-26T12:40:49.102742", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Comfort objects [Feature engineering]</h1>
# + papermill={"duration": 4.216441, "end_time": "2021-09-26T12:40:53.450380", "exception": false, "start_time": "2021-09-26T12:40:49.233939", "status": "completed"} tags=[]
def comfort_objects(df):
many_comfort_objects = []
for i in range(len(df['osm_amenity_points_in_0.001'])):
if df['osm_amenity_points_in_0.001'][i] > 1 or df['osm_amenity_points_in_0.005'][i] > 1 or df['osm_amenity_points_in_0.0075'][i] > 1 or df['osm_amenity_points_in_0.01'][i] > 1:
many_comfort_objects.append(1)
else:
many_comfort_objects.append(0)
df['many_comfort_objects'] = many_comfort_objects
df.drop(['osm_amenity_points_in_0.001', 'osm_amenity_points_in_0.005', 'osm_amenity_points_in_0.0075', 'osm_amenity_points_in_0.01'], axis=1, inplace=True)
comfort_objects(df_train)
# + [markdown] papermill={"duration": 0.063842, "end_time": "2021-09-26T12:40:53.578483", "exception": false, "start_time": "2021-09-26T12:40:53.514641", "status": "completed"} tags=[]
# <h1 style='background-color: #defcdc; border: 1px solid #a1d194; padding: 10px; font-weight: 400; text-align:center'>Quick Summary</h1>
# + papermill={"duration": 0.386951, "end_time": "2021-09-26T12:40:54.030083", "exception": false, "start_time": "2021-09-26T12:40:53.643132", "status": "completed"} tags=[]
print_unique_values(df_train)
# + [markdown] papermill={"duration": 0.064778, "end_time": "2021-09-26T12:40:54.161802", "exception": false, "start_time": "2021-09-26T12:40:54.097024", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>Analys</h1>
# + papermill={"duration": 0.122404, "end_time": "2021-09-26T12:40:54.350699", "exception": false, "start_time": "2021-09-26T12:40:54.228295", "status": "completed"} tags=[]
print_missing_values(df_train)
# + [markdown] papermill={"duration": 0.065472, "end_time": "2021-09-26T12:40:54.483459", "exception": false, "start_time": "2021-09-26T12:40:54.417987", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>Filling NA's</h1>
# + papermill={"duration": 0.110431, "end_time": "2021-09-26T12:40:54.659467", "exception": false, "start_time": "2021-09-26T12:40:54.549036", "status": "completed"} tags=[]
df_train['reform_house_population_500'] = df_train['reform_house_population_500'].fillna(df_train['reform_house_population_500'].median())
df_train['reform_house_population_1000'] = df_train['reform_house_population_1000'].fillna(df_train['reform_house_population_1000'].median())
df_train['reform_mean_floor_count_1000'] = df_train['reform_mean_floor_count_1000'].fillna(df_train['reform_mean_floor_count_1000'].median())
# df['reform_mean_floor_count_1000'] = df['reform_mean_floor_count_1000'].apply(lambda x: np.log(x+1))
df_train['reform_mean_floor_count_500'] = df_train['reform_mean_floor_count_500'].fillna(df_train['reform_mean_floor_count_500'].median())
df_train['reform_mean_year_building_1000'] = df_train['reform_mean_year_building_1000'].fillna(df_train['reform_mean_year_building_1000'].median())
df_train['reform_mean_year_building_500'] = df_train['reform_mean_year_building_500'].fillna(df_train['reform_mean_year_building_500'].median())
# + [markdown] papermill={"duration": 0.065699, "end_time": "2021-09-26T12:40:54.792378", "exception": false, "start_time": "2021-09-26T12:40:54.726679", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>'osm_city_nearest_population' missing values = 100%</h1>
# + papermill={"duration": 0.089463, "end_time": "2021-09-26T12:40:54.948716", "exception": false, "start_time": "2021-09-26T12:40:54.859253", "status": "completed"} tags=[]
print_missing_values(df_train[df_train['osm_city_nearest_population'].isnull()])
# + [markdown] papermill={"duration": 0.067037, "end_time": "2021-09-26T12:40:55.081931", "exception": false, "start_time": "2021-09-26T12:40:55.014894", "status": "completed"} tags=[]
# #### Summary
# All other features contain many missing values, so we will delete all this rows
# + papermill={"duration": 0.108354, "end_time": "2021-09-26T12:40:55.256976", "exception": false, "start_time": "2021-09-26T12:40:55.148622", "status": "completed"} tags=[]
df_train = df_train[df_train['osm_city_nearest_population'].notna()]
# + [markdown] papermill={"duration": 0.065955, "end_time": "2021-09-26T12:40:55.389916", "exception": false, "start_time": "2021-09-26T12:40:55.323961", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>'reform_mean_floor_count_500' missing values = 100%</h1>
# + papermill={"duration": 0.086449, "end_time": "2021-09-26T12:40:55.542150", "exception": false, "start_time": "2021-09-26T12:40:55.455701", "status": "completed"} tags=[]
print_missing_values(df_train[df_train['reform_mean_floor_count_500'].isnull()])
# + [markdown] papermill={"duration": 0.066392, "end_time": "2021-09-26T12:40:55.675003", "exception": false, "start_time": "2021-09-26T12:40:55.608611", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>'reform_mean_year_building_1000' missing values = 100%</h1>
# + papermill={"duration": 0.086139, "end_time": "2021-09-26T12:40:55.827542", "exception": false, "start_time": "2021-09-26T12:40:55.741403", "status": "completed"} tags=[]
print_missing_values(df_train[df_train['reform_mean_year_building_1000'].isnull()])
# + [markdown] papermill={"duration": 0.067913, "end_time": "2021-09-26T12:40:55.962611", "exception": false, "start_time": "2021-09-26T12:40:55.894698", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>'reform_mean_year_building_500' missing values = 100%</h1>
# + papermill={"duration": 0.088381, "end_time": "2021-09-26T12:40:56.118757", "exception": false, "start_time": "2021-09-26T12:40:56.030376", "status": "completed"} tags=[]
print_missing_values(df_train[df_train['reform_mean_year_building_500'].isnull()])
# + [markdown] papermill={"duration": 0.067797, "end_time": "2021-09-26T12:40:56.254475", "exception": false, "start_time": "2021-09-26T12:40:56.186678", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>Summary</h1>
# + papermill={"duration": 0.100748, "end_time": "2021-09-26T12:40:56.422718", "exception": false, "start_time": "2021-09-26T12:40:56.321970", "status": "completed"} tags=[]
print_missing_values(df_train)
# + [markdown] papermill={"duration": 0.067191, "end_time": "2021-09-26T12:40:56.557605", "exception": false, "start_time": "2021-09-26T12:40:56.490414", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>Fill 'reform_mean_floor_count_500' NA's by medians</h1>
# + papermill={"duration": 0.151372, "end_time": "2021-09-26T12:40:56.783758", "exception": false, "start_time": "2021-09-26T12:40:56.632386", "status": "completed"} tags=[]
print_missing_values(df_train)
# + [markdown] papermill={"duration": 0.070711, "end_time": "2021-09-26T12:40:56.924632", "exception": false, "start_time": "2021-09-26T12:40:56.853921", "status": "completed"} tags=[]
# <h1 style='background-color: #fecfffcd; border: 1px solid #d194cf; padding: 10px; font-weight: 400; text-align:center'>Fill 'floor' NA's</h1>
# + papermill={"duration": 0.078011, "end_time": "2021-09-26T12:40:57.071331", "exception": false, "start_time": "2021-09-26T12:40:56.993320", "status": "completed"} tags=[]
# df['floor'] = df['floor'].replace({'подвал': -1,'цоколь': 0,'антресоль' : 1.5,
# 'фактически на уровне 1 этажа':1,'тех.этаж (6)':6,
# 'подвал': 1,'цоколь, 1': 1,
# '1,2,антресоль':1.5,'Подвал':-1,
# 'Цоколь':0.6 ,'1,2,3':'1', 'подвал':'1'})
# flors = ['-1','1', '2', '1', '4', '5', '3',
# '0.6', '10', '6', '1', '1', '1', '1',
# '5', '1', '12', '15', '13',
# '1, ', '2', '1', '8', '7',
# '0', '3', '1',
# '1', '1', '4', '1,', '9',
# '1 ', '1', '1', '1',
# '4', '2', '4', '1', '18', '1',
# '0', '-1', '1', '3', '1',
# '1', '3', '1',
# '1', '3', '-1', '3', '11', '36', '7',
# '1', '1', '3', '4', '5', '1',
# '29', '-1, ', '3']
# old_flors = ['подвал', '1', '2', '1.5', '4', '5', '3',
# '0.6', '10', '6', '1, подвал', '1,2,3,4', '1,2', '1,2,3,4,5',
# '5, мансарда', '1-й, подвал', '12', '15', '13',
# '1, подвал, антресоль', 'мезонин', 'подвал, 1-3', '8', '7',
# '1 (Цокольный этаж)', '3, Мансарда (4 эт)', 'подвал,1',
# '1, антресоль', '1-3', 'мансарда (4эт)', '1, 2.', '9',
# 'подвал , 1 ', '1, 2', 'подвал, 1,2,3', '1 + подвал (без отделки)',
# 'мансарда', '2,3', '4, 5', '1-й, 2-й', '18', '1',
# '1, цоколь', 'подвал', '3 (антресоль)', '1, 2, 3',
# 'Цоколь, 1,2(мансарда)', 'подвал, 3. 4 этаж', 'подвал, 1-4 этаж',
# 'подва, 1.2 этаж', '2, 3', '-1', '1.2', '11', '36', '7,8',
# '1 этаж', '1-й', '3 этаж', '4 этаж', '5 этаж', 'подвал,1,2,3,4,5',
# '29', 'подвал, цоколь, 1 этаж', '3, мансарда']
# res = dict(zip (old_flors,flors))
# df['floor'] = df['floor'].replace(res)
# df['floor'] = df['floor'].replace({'подвал, 1':'0',np.nan:0})
# df['floor'] = df['floor'].replace({'1 этаж, подвал': '0', np.nan: 0})
# df['floor'].unique()
# + [markdown] papermill={"duration": 0.068983, "end_time": "2021-09-26T12:40:57.209640", "exception": false, "start_time": "2021-09-26T12:40:57.140657", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Split Data</h1>
# + papermill={"duration": 0.19086, "end_time": "2021-09-26T12:40:57.469335", "exception": false, "start_time": "2021-09-26T12:40:57.278475", "status": "completed"} tags=[]
X, y = df_train.loc[:, df_train.columns != 'per_square_meter_price'], df_train['per_square_meter_price']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# + [markdown] papermill={"duration": 0.069793, "end_time": "2021-09-26T12:40:57.607284", "exception": false, "start_time": "2021-09-26T12:40:57.537491", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Linear Regression</h1>
# + papermill={"duration": 0.366724, "end_time": "2021-09-26T12:40:58.042594", "exception": false, "start_time": "2021-09-26T12:40:57.675870", "status": "completed"} tags=[]
lg = LinearRegression()
lg.fit(X_train, y_train)
mean_squared_error(y_test, lg.predict(X_test))
# + [markdown] papermill={"duration": 0.068747, "end_time": "2021-09-26T12:40:58.231411", "exception": false, "start_time": "2021-09-26T12:40:58.162664", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Decision Tree Regressor</h1>
# + papermill={"duration": 5.697117, "end_time": "2021-09-26T12:41:03.997219", "exception": false, "start_time": "2021-09-26T12:40:58.300102", "status": "completed"} tags=[]
tree = DecisionTreeRegressor(random_state=3)
tree.fit(X_train, y_train)
mean_squared_error(y_test, tree.predict(X_test))
# + [markdown] papermill={"duration": 0.070458, "end_time": "2021-09-26T12:41:04.138324", "exception": false, "start_time": "2021-09-26T12:41:04.067866", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Random Forest Regressor</h1>
# + papermill={"duration": 365.927938, "end_time": "2021-09-26T12:47:10.135865", "exception": false, "start_time": "2021-09-26T12:41:04.207927", "status": "completed"} tags=[]
random_tree = RandomForestRegressor(random_state=3)
random_tree.fit(X_train, y_train)
mean_squared_error(y_test, random_tree.predict(X_test))
# + [markdown] papermill={"duration": 0.069923, "end_time": "2021-09-26T12:47:10.276371", "exception": false, "start_time": "2021-09-26T12:47:10.206448", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Gradient Boosting Regressor</h1>
# + papermill={"duration": 0.07525, "end_time": "2021-09-26T12:47:10.420443", "exception": false, "start_time": "2021-09-26T12:47:10.345193", "status": "completed"} tags=[]
# gb = GradientBoostingRegressor(random_state=3)
# gb.fit(X_train, y_train)
# mean_squared_error(y_test, gb.predict(X_test))
# + [markdown] papermill={"duration": 0.068956, "end_time": "2021-09-26T12:47:10.558863", "exception": false, "start_time": "2021-09-26T12:47:10.489907", "status": "completed"} tags=[]
# <h1 style='background-color: #dae8fc; border: 1px solid #94add0; padding: 10px; font-weight: 400; text-align:center'>Submission</h1>
# + papermill={"duration": 0.161733, "end_time": "2021-09-26T12:47:10.789890", "exception": false, "start_time": "2021-09-26T12:47:10.628157", "status": "completed"} tags=[]
df_test = pd.read_csv('../input/raifhackds2021fall/data/test.csv')
# + papermill={"duration": 0.104056, "end_time": "2021-09-26T12:47:10.963704", "exception": false, "start_time": "2021-09-26T12:47:10.859648", "status": "completed"} tags=[]
ID = df_test['id']
df_test.drop(['id', 'lat', 'lng', 'osm_city_nearest_name', 'date', 'street', 'floor', 'osm_city_closest_dist'], axis=1, inplace=True)
df_test['reform_house_population_500'] = df_test['reform_house_population_500'].fillna(df_test['reform_house_population_500'].median())
df_test['reform_house_population_1000'] = df_test['reform_house_population_1000'].fillna(df_test['reform_house_population_1000'].median())
df_test['reform_mean_floor_count_1000'] = df_test['reform_mean_floor_count_1000'].fillna(df_test['reform_mean_floor_count_1000'].median())
# df['reform_mean_floor_count_1000'] = df['reform_mean_floor_count_1000'].apply(lambda x: np.log(x+1))
df_test['reform_mean_floor_count_500'] = df_test['reform_mean_floor_count_500'].fillna(df_test['reform_mean_floor_count_500'].median())
df_test['reform_mean_year_building_1000'] = df_test['reform_mean_year_building_1000'].fillna(df_test['reform_mean_year_building_1000'].median())
df_test['reform_mean_year_building_500'] = df_test['reform_mean_year_building_500'].fillna(df_test['reform_mean_year_building_500'].median())
# + papermill={"duration": 1.013433, "end_time": "2021-09-26T12:47:12.046852", "exception": false, "start_time": "2021-09-26T12:47:11.033419", "status": "completed"} tags=[]
location(df_test)
cities_1m(df_test)
make_district(df_test)
offices(df_test)
food(df_test)
shops(df_test)
financial_organizations(df_test)
medecine(df_test)
entertainment(df_test)
hist_obj(df_test)
buildings(df_test)
hotels(df_test)
stations_score(df_test)
stations(df_test)
land_transport(df_test)
pedestrian_crossings(df_test)
culture_objects(df_test)
comfort_objects(df_test)
# + papermill={"duration": 0.282895, "end_time": "2021-09-26T12:47:12.399979", "exception": false, "start_time": "2021-09-26T12:47:12.117084", "status": "completed"} tags=[]
random_tree.predict(df_test)
# + papermill={"duration": 0.310342, "end_time": "2021-09-26T12:47:12.781180", "exception": false, "start_time": "2021-09-26T12:47:12.470838", "status": "completed"} tags=[]
output = pd.DataFrame({'id': ID, 'per_square_meter_price': random_tree.predict(df_test)})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!")
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import string
import requests as rq
from bs4 import BeautifulSoup as bs
import numpy as np
from nltk import bigrams, FreqDist
from nltk.corpus import stopwords
import matplotlib.pyplot as plt
# %matplotlib inline
en_stops = stopwords.words('english')
# -
res = rq.get('https://en.wikipedia.org/wiki/Python_(programming_language)')
soup = bs(res.content)
uls = soup.find_all('ul')
index = np.where(['Graphical user interfaces' in u.text for u in uls])[0][0]
index
ul = uls[index]
# the last link is a citation note
links = ['https://wikipedia.org/' + l.attrs['href'] for l in ul.find_all('a')[:-1]]
links
all_text = []
for l in links:
res = rq.get(l)
soup = bs(res.content)
all_text.extend(p.text for p in soup.find_all('p'))
full_text = ' '.join(all_text)
translator = str.maketrans('', '', string.punctuation + string.digits)
clean_text = full_text.translate(translator)
clean_words = [w for w in clean_text.lower().split() if w not in en_stops and len(w) > 3]
bgs = [' '.join(b) for b in bigrams(clean_words)]
bg_fd = FreqDist(bgs)
bg_fd.plot(20)
# It looks like machine learning is a huge focus of the related pages. we also see topics in and around computer science and sofetware engineering, as well as some specific topics like text and images.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
from math import sqrt, log
import pandas as pd
import matplotlib.pyplot as plt
# %matplotlib inline
import turicreate as tc
from sklearn import linear_model
# +
def get_numpy_data(data_sframe, features, output):
data_sframe['constant'] = 1 # add a constant column to an SFrame
# prepend variable 'constant' to the features list
features = ['constant'] + features
# select the columns of data_SFrame given by the ‘features’ list into the SFrame ‘features_sframe’
features_sframe = data_sframe[features]
# this will convert the features_sframe into a numpy matrix:
features_matrix = features_sframe.to_numpy()
# assign the column of data_sframe associated with the target to the variable ‘output_sarray’
output_sarray = data_sframe[output]
# this will convert the SArray into a numpy array:
output_array = output_sarray.to_numpy()
return(features_matrix, output_array)
def predict_output(feature_matrix, weights):
predictions = np.matmul(feature_matrix, weights)
return(predictions)
def feature_derivative(errors, feature):
derivative = -2 * np.dot(feature, errors)
return(derivative)
def normalize_features(features):
norms = np.linalg.norm(features, axis=0)
normalized_features = features/norms
return (normalized_features, norms)
# +
dtype_dict = {'bathrooms':float, 'waterfront':int, 'sqft_above':int, 'sqft_living15':float, 'grade':int, 'yr_renovated':int, 'price':float, 'bedrooms':float, 'zipcode':str, 'long':float, 'sqft_lot15':float, 'sqft_living':float, 'floors':float, 'condition':int, 'lat':float, 'date':str, 'sqft_basement':int, 'yr_built':int, 'id':str, 'sqft_lot':int, 'view':int}
sales = tc.SFrame('m_ef92e6258b8f7992.frame_idx')
(train_and_validation, test) = sales.random_split(.8, seed=1)
(train, validation) = train_and_validation.random_split(.8, seed=1)
feature_list = ['bedrooms',
'bathrooms',
'sqft_living',
'sqft_lot',
'floors',
'waterfront',
'view',
'condition',
'grade',
'sqft_above',
'sqft_basement',
'yr_built',
'yr_renovated',
'lat',
'long',
'sqft_living15',
'sqft_lot15']
features_train, output_train = get_numpy_data(train, feature_list, 'price')
features_test, output_test = get_numpy_data(test, feature_list, 'price')
features_valid, output_valid = get_numpy_data(validation, feature_list, 'price')
features_train, norms = normalize_features(features_train)
features_test = features_test / norms
features_valid = features_valid / norms
# -
print(features_test[0])
print (features_train[9])
euclidian_distance = np.sqrt(np.sum(np.square(features_test[9] - features_test[0])))
print(euclidian_distance)
# +
dist_dict = {}
for i in range(0,10):
dist_dict[i] = np.sqrt(np.sum((features_train[i] - features_test[0])**2))
print (i, np.sqrt(np.sum((features_train[i] - features_test[0])**2)))
print (min(dist_dict.items(), key=lambda x: x[1]))
# -
for i in range(3):
print (features_train[i]-features_test[0])
print (features_train[0:3] - features_test[0])
# verify that vectorization works
results = features_train[0:3] - features_test[0]
print (results[0] - (features_train[0]-features_test[0]))
# should print all 0's if results[0] == (features_train[0]-features_test[0])
print (results[1] - (features_train[1]-features_test[0]))
# should print all 0's if results[1] == (features_train[1]-features_test[0])
print (results[2] - (features_train[2]-features_test[0]))
# should print all 0's if results[2] == (features_train[2]-features_test[0])
diff = features_train - features_test[0]
print (diff[-1].sum())
print (np.sum(diff**2, axis=1)[15]) # take sum of squares across each row, and print the 16th sum
print (np.sum(diff[15]**2)) # print the sum of squares for the 16th row -- should be same as above
distances = np.sqrt(np.sum(diff**2, axis=1))
distances[100]
def compute_distances(train_matrix, query_vector):
diff = train_matrix - query_vector
distances = np.sqrt(np.sum(diff**2, axis=1))
return distances
third_house_distance = compute_distances(features_train, features_test[2])
print (third_house_distance.argsort()[0], min(third_house_distance))
print (third_house_distance[382])
def k_nearest_neighbors(k, feature_train, features_query):
distances = np.array(compute_distances(feature_train, features_query))
sort_arg = np.argsort(distances, axis = 0)[:k]
neighbors = sort_arg
return neighbors
print(k_nearest_neighbors(4, features_train, features_test[2]))
def predict_output_of_query(k, features_train, output_train, features_query):
k_neighbors = k_nearest_neighbors(k, features_train, features_query)
prediction = np.mean(output_train[k_neighbors])
return prediction
print(predict_output_of_query(4, features_train, output_train, features_test[2]))
def predict_output(k, features_train, output_train, features_query):
num_of_rows = features_query.shape[0]
predictions = []
for i in range(num_of_rows):
avg_value = predict_output_of_query(k, features_train, output_train, features_query[i])
predictions.append(avg_value)
return predictions
predicted_values = predict_output(10, features_train, output_train, features_test[0:10])
print (predicted_values)
print (predicted_values.index(min(predicted_values)))
print (min(predicted_values))
rss_all = []
for k in range(1,16):
predict_value = predict_output(k, features_train, output_train, features_valid)
residual = (output_valid - predict_value)
rss = np.sum(residual**2)
rss_all.append(rss)
print (rss_all)
print (rss_all.index(min(rss_all)))
predict_value = predict_output(14, features_train, output_train, features_test)
residual = (output_test - predict_value)
rss = sum(residual**2)
print (rss)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Forecast of Norway's electrical vehicle market
# _by Roald Ruiter, 10 November 2017_
#
# Norway has been aggressively promoting the purchase of electric cars. Currently about half of the sold cars are electric. So how long will it take them to replace all their internal combustion cars for electric ones?
#
# Well, from the [Global EV outlook 2017](https://www.iea.org/publications/freepublications/publication/GlobalEVOutlook2017.pdf) table 5 page 49 we can obtain the total amount of electric cars in the country. Second, the total amount of private cars in Norway is about [2.7 million](https://www.ssb.no/en/bilreg). If we also include the vans it becomes 3.1 million.
#
# Let's use these figures to find out find out when all internal combustion cars will be replaced, using a [model](https://github.com/Roald87/ev_forecast/blob/master/Market_share_electric_vehicles.ipynb) I made earlier.
# +
from forecast import Forecast
import numpy as np
import matplotlib.pyplot as plt
# The input data from the Global EV outlook 2017
EV_stock = np.array([
10,
260,
400,
3350,
5380,
9550,
19680,
41800,
72040,
98880,
])
stock_years = np.array([year for year, _ in enumerate(EV_stock, 2007)])
plt.scatter(stock_years, EV_stock)
plt.yscale('log')
plt.xlabel('Year')
plt.ylabel('Electric vehicle stock')
plt.title('Total battery electric vehicle stock in Norway')
plt.show()
# -
# ## Thoughts on the data
#
# The years 2007 - 2009, are a bit off from the rest of the data. For the first try I'll exclude these years.
#
# ## Fitting the exponential growht phase
# +
ev_forecast = Forecast(EV_stock, stock_years, saturation=2.6e6, tau_life=15)
# Excluding the years 2007-2009 from the fit
ev_forecast.set_fit_range(stock_years[3:])
ev_forecast.set_plot_labels(
'Year', 'Stock',
"Norway's stock of battery electric vehicles"
)
ev_forecast.plot_exponential_phase(figsize=(10,6))
growth_rate = float(ev_forecast.tau_exp)
print('The growth rate is {:.2f} years and the transition year is {}.'
.format(growth_rate, ev_forecast.get_transistion_year()))
print('The meaning of the growth rate is that each {:.2f} years the amount of '
'electric vehicles grows by a factor of exp(1) = 2.72'
.format(growth_rate))
# -
# ## Thoughts on the exponential growth phase
#
# Based on the model, this year (2017) is when the exponential growth of the Norwegian electric vehicle market will stop and transition to a linear growth.
#
# ## Looking at the complete picture
# +
ev_forecast.plot_all_phases(figsize=(15, 10))
print('The earliest at which all vehicles in Norway can be replaced '
'by electrical ones is {}. That is assuming a car lifetime of '
'{} years and a total {} million vehicles in the country.'
.format(ev_forecast.get_saturation_year(),
ev_forecast.tau_life,
ev_forecast.saturation/1e6))
# -
# ## Exploring different market sizes/vehicle lifetimes
#
# So what if the market is bigger or the vehicle lifetime is shorter?
for saturation, lifetime in [(2.6e6, 10), (3.1e6, 15), (3.1e6, 10)]:
ev_forecast = Forecast(EV_stock, stock_years, saturation=saturation, tau_life=lifetime)
# Excluding the years 2007-2009 from the fit
ev_forecast.set_fit_range(stock_years[3:])
print('Replacing {} million vehicles, assuming a car lifetime of {} years, '
'can be done by {}.\n'
'The transition from exponential to linear growth will take place around {}'
.format(
saturation/1e6,
lifetime,
ev_forecast.get_saturation_year(),
ev_forecast.get_transistion_year())
)
# ## What if we include all data?
#
# So also the data from 2007-2009
for saturation, lifetime in [(2.6e6, 15), (2.6e6, 10), (3.1e6, 15), (3.1e6, 10)]:
ev_forecast = Forecast(EV_stock, stock_years, saturation=saturation, tau_life=lifetime)
print('Replacing {} million vehicles, assuming a car lifetime of {} years, '
'can be done by {}.'
.format(saturation/1e6, lifetime, ev_forecast.get_saturation_year()))
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Rebinning Multi-Analyzer data from ID22 taken with a 2D detector
#
# This notebooks presents how to agregate together on a same $2\theta$ grid all data coming from all pixels of the Eiger 2M detector.
#
# ## Introduction of the Multi-Analyzer stage for high resolution powder diffraction:
#
# 
# 
#
# Please ensure you first read: [J. Appl. Cryst. (2021). 54, 1088-1099](https://doi.org/10.1107/S1600576721005288).
#
# Author: Jérôme Kieffer, ESRF
# %matplotlib nbagg
# Compile the library
# !pwd
# ! cd .. && python3 setup.py build && cd -
import sys
import os
import time
import numpy
import h5py
import json
from matplotlib.pyplot import subplots
from matplotlib import colors
from scipy.signal import find_peaks
sys.path.append("../build/lib.linux-x86_64-3.9/")
from multianalyzer import MultiAnalyzer, ID22_bliss_parser, topas_parser
start_time = time.perf_counter()
# +
# #%%time
#Nota this cell takes a while to read all frames and perform a max-filter on the stack
# #!pyFAI-average -m max -F numpy -o max.npy /mnt/data/ID22/MultiAnalyzer/LaB6_31keV_150921/LaB6_31keV_150921_0001/LaB6_31keV_150921_0001.h5::/1.1/instrument/eiger/data
# -
fig, ax = subplots(figsize=(9,3))
img = numpy.load("max.npy")
ax.imshow(img, norm=colors.LogNorm(vmin=1, vmax=65000), origin="lower")
_ = ax.set_title("Max-filtered stack of images")
# ## Read the configuration of the various analyzers
topas = "out7.pars"
print(open(topas).read())
param = topas_parser(topas)
print(json.dumps(param, indent=2))
# ## Read the ROI-collection from HDF5 file.
#
# This is a substential amount of data and takes up to a minute!
# #!scp scisoft13:/data/id22/inhouse/id222108/id22/LaB6_35keV_mantr10_nozzle20_1/LaB6_35keV_mantr10_nozzle20_1_0001/LaB6_35keV_mantr10_nozzle20_1_0001.h5 /tmp
# #!md5sum /tmp/LaB6_35keV_mantr10_nozzle20_1_0001.h5
# #!md5sum /mnt/data/ID22/MultiAnalyzer/LaB6_35keV_mantr10_nozzle20_1/id222108_LaB6_35keV_mantr10_nozzle20_1.h5
hdf5 = "/mnt/data/ID22/analyzer13/LaB6_35keV_mantr10_nozzle20_1/LaB6_35keV_mantr10_nozzle20_1_0001/LaB6_35keV_mantr10_nozzle20_1_0001.h5"
print(f"Size of the input file: {os.stat(hdf5).st_size>>10} MB")
# %%time
hdf5_data = ID22_bliss_parser(hdf5)
print(hdf5_data)
print("Shape of the ROI-collection:", hdf5_data["roicol"].shape)
# ## Perform the rebinning
# +
# Ensure all units are consitent. Here lengths are in milimeters.
L = param["L1"]
L2 = param["L2"]
pixel = 75e-3
# Angles are all given in degrees
center = numpy.array(param["centre"])
psi = numpy.rad2deg(param["offset"])
rollx = numpy.rad2deg(param["rollx"])
rolly = numpy.rad2deg(param["rolly"])
# tha = hdf5_data["tha"]
# thd = hdf5_data["thd"]
tha = numpy.rad2deg(param["manom"])
thd = numpy.rad2deg(param["mantth"])
# Finally initialize the rebinning engine.
mma = MultiAnalyzer(L, L2, pixel, center, tha, thd, psi, rollx, rolly)
# -
tha, thd
roi_step = 1
# +
#Display the 2theta position of all ROI for a given arm position
arm = 6.9
fig, ax = subplots()
x = range(512)
for a in range(13):
ax.plot(x, [mma.refine(i, a, arm, phi_max=8) for i in x], label=f"MA{a}")
ax.set_xlabel("Pixel index")
ax.set_xlabel(r"$2\theta$ position of pixel")
ax.set_title(f"Arm is at {arm} °")
_ = ax.legend()
# -
# %%time
roicol = hdf5_data["roicol"]
arm = hdf5_data["arm"]
mon = hdf5_data["mon"]
res = mma.integrate(roicol, arm, mon, 3.383800, 45.099600, 3.5e-4, 90, 29, 40, resolution=1e-4)
#Load the reference data:
ref = numpy.loadtxt("LaB6_35keV_all.xye").T
fig, ax = subplots()
scale = ref[1].mean() / numpy.nanmean(res[1]/res[2])
for i in range(0, 13, 1):
ax.plot(res[0], scale*res[1][i]/res[2][i], "--", label=f"MA{i}")
ax.plot(ref[0],ref[1], "-b", label="ref")
ax.set_xlabel(r"$2\theta$ (°)")
ax.set_ylabel("Scattered intensity")
ax.set_title("LaB6")
ax.legend()
# ## Perform some basic profile analysis
#
# This is not a Rietveld, nor a Pawley refinement but it gives some insights on the intrinsic width of the signal
pk = find_peaks(ref[1], width=(5, 50), prominence=1000, distance=400)
fig,ax = subplots()
ax.plot(ref[1])
ax.plot(pk[0], pk[1]["prominences"], ".")
_ = ax.set_xlabel("index")
# %%time
res = mma.integrate(roicol, arm, mon,
tth_min=3.383800, tth_max=45.099600, dtth=3.5e-4,
phi_max=90,
roi_min=29, roi_max=512, roi_step=roi_step,
resolution=1e-4)
fig, ax = subplots()
delta = (ref[0][-1] - ref[0][0])/(len(ref[0])-1)
delta1 = (res[0][-1] - res[0][0])/(len(res[0])-1)
ax.set_xlabel(r"$2\theta$ (°)")
ax.set_ylabel("FWHM (°)")
for i in range(0, 13, 1):
sig = scale*res[1][i, :-1]/res[2][i, :-1]
pks = find_peaks(sig, width=(10, 150), prominence=1000, distance=1000)
ax.plot(res[0][:-1][pks[0]], delta1*pks[1]["widths"], "--", label=f"MA{i}")
ax.plot(ref[0][pk[0]], delta*pk[1]["widths"], "-b", label="Ref")
_ = ax.legend()
weights = numpy.array([float(i) for i in open("temp.res").read().split(",")
if i.strip()]).reshape((13, -1))[:, 1]
sig_tot = (weights.reshape((13, -1)) * res[1]).sum(axis=0)
norm_tot = (weights.reshape((13, -1)) * res[2]).sum(axis=0)
intensity = sig_tot/norm_tot
fig, ax = subplots(figsize=(10,8))
scale = ref[1].mean() / numpy.nanmean(intensity)
ax.plot(res[0],intensity*scale, "-g", label="tot")
ax.plot(ref[0],ref[1], "-b", label="ref")
ax.set_xlabel(r"$2\theta$ (°)")
ax.set_ylabel("Scattered intensity")
ax.set_title("LaB6")
ax.legend()
pki = find_peaks(intensity*scale, width=(10, 200), distance=800, prominence=1000)
fig,ax = subplots()
ax.plot(intensity*scale)
ax.plot(pki[0], pki[1]["prominences"], ".")
_ = ax.set_xlabel("index")
fig, ax = subplots()
delta = (ref[0][-1] - ref[0][0])/(len(ref[0])-1)
delta1 = (res[0][-1] - res[0][0])/(len(res[0])-1)
ax.set_xlabel(r"$2\theta$ (°)")
ax.set_ylabel("FWHM (°)")
ax.plot(ref[0][pk[0]], delta*pk[1]["widths"], "-b", label="Reference")
ax.plot(res[0][pki[0]], delta1*pki[1]["widths"], "-g", label="MultiAnalyzer")
_ = ax.legend()
# ## Now limit to Phi<10°
# +
# %%time
phi_max = 10
res = mma.integrate(roicol, arm, mon,
tth_min=3.383800, tth_max=45.099600, dtth=3.5e-4,
phi_max=phi_max,
roi_min=29, roi_max=512, roi_step=roi_step,
resolution=1e-4)
sig_tot = (weights.reshape((13, -1)) * res[1]).sum(axis=0)
norm_tot = (weights.reshape((13, -1)) * res[2]).sum(axis=0)
intensity = sig_tot/norm_tot
scale = ref[1].mean() / numpy.nanmean(intensity)
pki = find_peaks(intensity*scale, width=(10, 200), distance=800, prominence=1000)
# +
fig, ax = subplots(2,figsize=(10,15))
ax[0].plot(res[0],intensity*scale, "-g", label="tot")
ax[0].plot(ref[0],ref[1], "-b", label="ref")
ax[0].set_xlabel(r"$2\theta$ (°)")
ax[0].set_ylabel("Scattered intensity")
ax[0].set_title("LaB6")
ax[0].legend()
delta = (ref[0][-1] - ref[0][0])/(len(ref[0])-1)
delta1 = (res[0][-1] - res[0][0])/(len(res[0])-1)
ax[1].set_xlabel(r"$2\theta$ (°)")
ax[1].set_ylabel("FWHM (°)")
ax[1].plot(ref[0][pk[0]], delta*pk[1]["widths"], "-b", label="Reference")
ax[1].plot(res[0][pki[0]], delta1*pki[1]["widths"], "-g", label="MultiAnalyzer")
ax[1].legend()
pass
# -
# ## Save data as text file
res3 = numpy.vstack((res[0], intensity*scale, numpy.sqrt(((weights*weights).reshape((13, -1)) * res[1]).sum(axis=0))*scale/norm_tot))
numpy.savetxt("LaB6.xye", res3.T, fmt='%.5f')
# ## Conclusion
# This notebook explains how to rebin data coming from the new experimental setup from ID22.
print(f"Total execution time: {time.perf_counter()-start_time:.3f}s")
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Search
# * The key to the status of DFS is current path.
# * DFS <-> DP Top Down <-> Memoization Table <-> Recursion
# * When finding all possible routes, we should use DFS to touch every end, i.e. [Word Break II](https://leetcode.com/problems/word-break-ii/).
#
# * The key to the status of BFS is level.
# * BFS <-> DP Bottom Up <-> Growing Table
# ## Pre-run
from typing import List
from helpers.misc import *
# ## 17 [Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/) - M
# ### BFS
# * Runtime: 28 ms, faster than 67.82% of Python3 online submissions for Letter Combinations of a Phone Number.
# * Memory Usage: 12.7 MB, less than 100.00% of Python3 online submissions for Letter Combinations of a Phone Number.
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
'''Given a string containing digits from 2-9 inclusive, return all
possible letter combinations that the number could represent.'''
# no digit
if not digits:
return []
key_map = {
2 : ['a', 'b', 'c'],
3 : ['d', 'e', 'f'],
4 : ['g', 'h', 'i'],
5 : ['j', 'k', 'l'],
6 : ['m', 'n', 'o'],
7 : ['p', 'q', 'r', 's'],
8 : ['t', 'u', 'v'],
9 : ['w', 'x', 'y', 'z']
}
ans = ['']
for d in digits:
new_ans = [x+y for x in ans for y in key_map[int(d)]]
ans = new_ans
return ans
# test
eq(Solution().letterCombinations("293"), ['awd', 'awe', 'awf', 'axd', 'axe',
'axf', 'ayd', 'aye', 'ayf', 'azd',
'aze', 'azf', 'bwd', 'bwe', 'bwf',
'bxd', 'bxe', 'bxf', 'byd', 'bye',
'byf', 'bzd', 'bze', 'bzf', 'cwd',
'cwe', 'cwf', 'cxd', 'cxe', 'cxf',
'cyd', 'cye', 'cyf', 'czd', 'cze',
'czf'])
# ### DFS (Backtracking)
# * Runtime: 44 ms, faster than 6.92% of Python3 online submissions for Letter Combinations of a Phone Number.
# * Memory Usage: 12.8 MB, less than 98.53% of Python3 online submissions for Letter Combinations of a Phone Number.
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
'''Given a string containing digits from 2-9 inclusive, return all
possible letter combinations that the number could represent.'''
key_map = {
2 : ['a', 'b', 'c'],
3 : ['d', 'e', 'f'],
4 : ['g', 'h', 'i'],
5 : ['j', 'k', 'l'],
6 : ['m', 'n', 'o'],
7 : ['p', 'q', 'r', 's'],
8 : ['t', 'u', 'v'],
9 : ['w', 'x', 'y', 'z']
}
ans = []
def dfs(track: str, digits: str) -> None:
'''Do DFS search in backtracking method
track: Current track
digits: Digits to parse
'''
# no digit for parsing, take the result
if not digits:
ans.append(track)
else:
# parse the first digit
for ch in key_map[int(digits[0])]:
dfs(track+ch, digits[1:])
# no digit causes empty answer
if digits:
dfs("", digits)
return ans
# test
eq(Solution().letterCombinations("293"), ['awd', 'awe', 'awf', 'axd', 'axe',
'axf', 'ayd', 'aye', 'ayf', 'azd',
'aze', 'azf', 'bwd', 'bwe', 'bwf',
'bxd', 'bxe', 'bxf', 'byd', 'bye',
'byf', 'bzd', 'bze', 'bzf', 'cwd',
'cwe', 'cwf', 'cxd', 'cxe', 'cxf',
'cyd', 'cye', 'cyf', 'czd', 'cze',
'czf'])
# ## 39 [Combination Sum](https://leetcode.com/problems/combination-sum/) - M
# ### DFS
# * Runtime: 84 ms, faster than 52.18% of Python3 online submissions for Combination Sum.
# * Memory Usage: 12.8 MB, less than 100.00% of Python3 online submissions for Combination Sum.
class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
'''Given a set of candidate numbers (candidates) (without duplicates)
and a target number (target), find all unique combinations in
candidates where the candidate numbers sums to target.'''
res = []
def dfs(current: List[int], candidates: List[int], target: int):
'''DFS way to find the result.
current: current answer
candidates: candidates of numbers
target: target number
'''
# no possible result
if target < 0:
pass
# result found
elif target == 0:
res.append(current)
else:
# TRICK: prevent duplicate combinations
for i, candidate in enumerate(candidates):
dfs(current+[candidate], candidates[i:], target-candidate)
dfs([], candidates, target)
return res
# test
eq(len(Solution().combinationSum([2,3,6,7], 7)), len([[7], [2,2,3]]))
# ## 40 [Combination Sum II](https://leetcode.com/problems/combination-sum-ii) - M
# ### DFS
# * Runtime: 44 ms, faster than 85.75% of Python3 online submissions for Combination Sum.
# * Memory Usage: 12.6 MB, less than 100.00% of Python3 online submissions for Combination Sum.
from copy import deepcopy
class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
'''Combination Sum II using DFS'''
ans = []
cur = []
# TRICK: sort for easier deduplication
candidates.sort()
def dfs(seq: int, t: int):
'''Use DFS to solve problem.
seq: current seq in candidates.
t: current target
'''
if t == 0:
ans.append(deepcopy(cur))
return
for i in range(seq, len(candidates)):
num = candidates[i]
# prune
if num > t:
return
# TRICK: deduplication
if i > seq and candidates[i] == candidates[i-1]:
continue
cur.append(num)
dfs(i+1, t-num)
cur.pop()
dfs(0, target)
return ans
# +
# test
# -
# ## 77 [Combinations](https://leetcode.com/problems/combinations/) - M
# ### DFS
# * Runtime: 584 ms, faster than 32.65% of Python3 online submissions for Combination Sum.
# * Memory Usage: 14.1 MB, less than 100.00% of Python3 online submissions for Combination Sum.
from copy import deepcopy
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
'''Given two integers n and k, return all possible COMBINATIONs of k numbers out of 1 ... n.
CAUTION: COMBINATION means that all subresult is ordered.
'''
ans = [] # final answer
cur = [] # answer buffer
def dfs(cn: int):
'''Use DFS to solve this problem
cn: current number for processing
'''
if len(cur) == k:
ans.append(deepcopy(cur))
return
else:
for i in range(cn, n):
cur.append(i+1)
dfs(i+1)
# TRICK: use only 1 cur to store current answer, no need to have slices for all answers or make cur as an argument.
cur.pop()
dfs(0)
return ans
# test
eq(len(Solution().combine(4, 2)), 6)
# ## 78 [Subsets](https://leetcode.com/problems/subsets/) - M
# ### BFS Iteration
# * Runtime: 28 ms, faster than 88.37% of Python3 online submissions for Subsets.
# * Memory Usage: 12.9 MB, less than 100.00% of Python3 online submissions for Subsets.
class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
'''Get all possible subsets from a list using BFS iteration.'''
ans = [[]]
h = {v:i for i, v in enumerate(nums)}
pre = []
for i in range(len(nums)):
if i == 0:
pre = [[x] for x in nums]
else:
nxt = []
for p in pre:
seq = h[p[-1]]
nxt += [p+[x] for x in nums[seq+1:]]
ans += pre
pre = nxt
return ans + pre
# test
eq(len(Solution().subsets([1,2,3])), len([[],[1],[2],[3],[1,2],[1,3],[2,3],
[1,2,3]]))
# ### BFS Recursion
# * Runtime: 24 ms, faster than 97.27% of Python3 online submissions for Subsets.
# * Memory Usage: 12.9 MB, less than 100.00% of Python3 online submissions for Subsets.
class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
'''Get all possible subsets from a list using BFS Recursion.'''
ans = [[]]
def rec(nums: List[int]) -> List[List[int]]:
'''Recursion function.'''
if not nums:
return ans
num = nums.pop()
for s in ans[:len(ans)]:
ans.append([num] + s)
return rec(nums)
return rec(nums)
# test
eq(len(Solution().subsets([1,2,3])), len([[],[1],[2],[3],[1,2],[1,3],[2,3],
[1,2,3]]))
# ## 90 [Subsets II](https://leetcode.com/problems/subsets-ii/) - M
# ### Brute BFS Recursion
# * Runtime: 44 ms, faster than 25.60% of Python3 online submissions for Subsets II.
# * Memory Usage: 12.8 MB, less than 100.00% of Python3 online submissions for Subsets II.
class Solution:
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
'''Get all possible subsets from a list using BFS Recursion.'''
ans = [[]]
nums.sort()
def rec(nums: List[int]) -> List[List[int]]:
'''Recursion function.'''
if not nums:
return ans
num = nums.pop()
for s in ans[:len(ans)]:
if [num]+s not in ans:
ans.append([num] + s)
return rec(nums)
return rec(nums)
# test
eq(len(Solution().subsetsWithDup([4,4,4,1,4])), len([[],[1],[1,4],[1,4,4],
[1,4,4,4],[1,4,4,4,4],[4],[4,4],[4,4,4],[4,4,4,4]]))
# ### DFS Recursion
# * Runtime: 36 ms, faster than 68.35% of Python3 online submissions for Subsets II.
# * Memory Usage: 13 MB, less than 100.00% of Python3 online submissions for Subsets II.
from copy import deepcopy
class Solution:
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
'''Get all possible subsets from a list using DFS recursion.'''
ans = []
cur = []
nums.sort()
def dfs(n: int):
'''DFS recursion'''
ans.append(deepcopy(cur))
for i in range(n, len(nums)):
# TRICK: discard duplicate answers
if i > n and nums[i] == nums[i-1]:
continue
cur.append(nums[i])
dfs(i+1)
cur.pop()
dfs(0)
return ans
# test
eq(len(Solution().subsetsWithDup([4,4,4,1,4])), len([[],[1],[1,4],[1,4,4],
[1,4,4,4],[1,4,4,4,4],[4],[4,4],[4,4,4],[4,4,4,4]]))
# ## 79 [Word Search](https://leetcode.com/problems/word-search/) - M
# ### DFS
# * Runtime: 800 ms, faster than 5.00% of Python3 online submissions for Word Search.
# * Memory Usage: 18.2 MB, less than 14.89% of Python3 online submissions for Word Search.
from collections import deque
class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
'''Do word search by DFS.'''
if not word:
return False
N = len(word)
# key: letters
# val: list of coordinations
dictionary = {}
# build the dictionary
for x, row in enumerate(board):
for y, letter in enumerate(row):
if letter not in dictionary:
dictionary[letter] = deque()
dictionary[letter].append([x, y])
# search
init_letter = word[0]
if len(word) == 1:
return init_letter in dictionary
if init_letter not in dictionary:
return False
moves = {(-1, 0), (1, 0), (0, 1), (0, -1)}
def dfs(index: int, x: int, y: int) -> bool:
'''Search by DFS from index.'''
if index == N:
return True
if word[index] not in dictionary:
return False
cnt = 0
cnt_max = len(dictionary[word[index]])
while cnt < cnt_max:
nx, ny = dictionary[word[index]].popleft()
if ((nx-x, ny-y) in moves) and (dfs(index+1, nx, ny) == True):
return True
dictionary[word[index]].append((nx, ny))
cnt += 1
return False
cnt = 0
cnt_max = len(dictionary[init_letter])
while cnt < cnt_max:
x, y = dictionary[init_letter].popleft()
if dfs(1, x, y) == True:
return True
dictionary[init_letter].append((x, y))
cnt += 1
return False
# test
eq(Solution().exist([["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], "ABCCED"), True)
eq(Solution().exist([["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], "ABCCFB"), False)
# ## 542 [01 Matrix](https://leetcode.com/problems/01-matrix/) - M
# ### DP
# * [Solution](https://leetcode.com/articles/01-matrix/)
# * **CAUTION**: must not use `ans = [[float('inf')]*ly]*lx`, for `*` makes **SHALLOW COPY**!!!
# * Runtime: 680 ms, faster than 77.21% of Python3 online submissions for 01 Matrix.
# * Memory Usage: 15.9 MB, less than 25.00% of Python3 online submissions for 01 Matrix.
class Solution:
def updateMatrix(self, matrix: List[List[int]]) -> List[List[int]]:
'''Find the distance of the nearest 0 for each cell.'''
if not matrix:
return []
lx = len(matrix)
ly = len(matrix[0])
# CAUTION: must not use ans = [[float('inf')]*ly]*lx, for * makes
# SHALLOW COPY!!!
# ans = []
# for x in range(lx):
# ans.append([])
# for y in range(ly):
# ans[x].append(float('inf'))
ans = [[float('inf') for _ in range(ly)] for _ in range(lx)]
# traverse right and down
for x in range(lx):
for y in range(ly):
if matrix[x][y] == 0:
ans[x][y] = 0
else:
if x > 0:
ans[x][y] = min(ans[x][y], ans[x-1][y]+1)
if y > 0:
ans[x][y] = min(ans[x][y], ans[x][y-1]+1)
# traverse left and up
for x in range(lx-1, -1, -1):
for y in range(ly-1, -1, -1):
if matrix[x][y] == 0:
ans[x][y] = 0
else:
if x < lx-1:
ans[x][y] = min(ans[x][y], ans[x+1][y]+1)
if y < ly-1:
ans[x][y] = min(ans[x][y], ans[x][y+1]+1)
return ans
# test
eq(Solution().updateMatrix([[0,0,0],[0,1,0],[1,1,1]]), [[0,0,0],[0,1,0],
[1,2,1]])
# ## 386 [Lexicographical Numbers](https://leetcode.com/problems/lexicographical-numbers/) - ByteDance - M
# ### O(1) Iteration
# * Get the O(n) answer by generating next number one by one.
# * Runtime: 124 ms, faster than 32.65% of Python3 online submissions for Lexicographical Numbers.
# * Memory Usage: 18.5 MB, less than 100.00% of Python3 online submissions for Lexicographical Numbers.
class Solution:
def lexicalOrder(self, n: int) -> List[int]:
'''Get lexical order from 1-n.'''
lex = []
len_lex = 0
current_number = 1
length_of_str_n = len(str(n))
while len_lex < n:
lex.append(current_number)
len_lex += 1
if len(str(current_number)) < length_of_str_n:
current_number *= 10
if current_number > n:
current_number //= 10
while current_number%10 == 9:
current_number //= 10
current_number += 1
elif current_number < n and current_number%10 != 9:
current_number += 1
else:
current_number //= 10
while current_number%10 == 9:
current_number //= 10
current_number += 1
return lex
# ### Brute Force
# * Runtime: 112 ms, faster than 53.35% of Python3 online submissions for Lexicographical Numbers.
# * Memory Usage: 19.8 MB, less than 50.00% of Python3 online submissions for Lexicographical Numbers.
class Solution:
def lexicalOrder(self, n: int) -> List[int]:
'''Get lexical order from 1-n.'''
return sorted([i for i in range(1, n+1)], key=lambda k : str(k))
# test
Solution().lexicalOrder(10)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3.8.12 ('aiffel_3.8')
# language: python
# name: python3
# ---
# # 14. 거울아 거울아, 나는 멍멍이 상이니, 아니면 냥이 상이니?
#
# **이미지 분류기 모델을 응용하여 개와 고양이를 분류하는 모델을 만들어 본다. 이를 응용하여 사람이 개와 고양이 중 어느쪽을 더 닮았는지 알아보는 재미있는 어플리케이션을 구현해 본다.**
# ## 14-1. 🐶 거울아 거울아, 나는 멍멍이 상이니, 아니면 냥이 상이니?
# ```bash
# $ pip install pillow
# ```
# +
import warnings
warnings.filterwarnings("ignore")
print("완료!")
# -
# ## 14-2. 내가 직접 만드는 강아지 고양이 분류기 (1) 이미지 분류 문제
import tensorflow as tf
print(tf.__version__)
# ## 14-3. 내가 직접 만드는 강아지 고양이 분류기 (2) 모델이 학습하려면? 공부할 데이터를 줘야지!
# +
import tensorflow_datasets as tfds
tfds.__version__
# -
(raw_train, raw_validation, raw_test), metadata = tfds.load(
'cats_vs_dogs',
split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
with_info=True,
as_supervised=True,
)
print(raw_train)
print(raw_validation)
print(raw_test)
# ## 14-4. 내가 직접 만드는 강아지 고양이 분류기 (3) 데이터가 있다고 끝은 아니야, 이쁘게 다듬는 작업은 필수!
# +
import matplotlib.pyplot as plt
# %matplotlib inline
# %config InlineBackend.figure_format = 'retina'
print("슝~")
# +
plt.figure(figsize=(10, 5))
get_label_name = metadata.features['label'].int2str
for idx, (image, label) in enumerate(raw_train.take(10)): # 10개의 데이터를 가져 옵니다.
plt.subplot(2, 5, idx+1)
plt.imshow(image)
plt.title(f'label {label}: {get_label_name(label)}')
plt.axis('off')
# +
IMG_SIZE = 160 # 리사이징할 이미지의 크기
def format_example(image, label):
image = tf.cast(image, tf.float32) # image=float(image)같은 타입캐스팅의 텐서플로우 버전입니다.
image = (image/127.5) - 1 # 픽셀값의 scale 수정
image = tf.image.resize(image, (IMG_SIZE, IMG_SIZE))
return image, label
print("슝~")
# +
train = raw_train.map(format_example)
validation = raw_validation.map(format_example)
test = raw_test.map(format_example)
print(train)
print(validation)
print(test)
# +
plt.figure(figsize=(10, 5))
get_label_name = metadata.features['label'].int2str
for idx, (image, label) in enumerate(train.take(10)):
plt.subplot(2, 5, idx+1)
image = (image + 1) / 2
plt.imshow(image)
plt.title(f'label {label}: {get_label_name(label)}')
plt.axis('off')
# -
# ## 14-5. 내가 직접 만드는 강아지 고양이 분류기 (4) 데이터가 준비되었으니, 이제 모델을 만들어보자
# +
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, Flatten, MaxPooling2D
print("슝~")
# +
model = Sequential([
Conv2D(filters=16, kernel_size=3, padding='same', activation='relu', input_shape=(160, 160, 3)),
MaxPooling2D(),
Conv2D(filters=32, kernel_size=3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(filters=64, kernel_size=3, padding='same', activation='relu'),
MaxPooling2D(),
Flatten(),
Dense(units=512, activation='relu'),
Dense(units=2, activation='softmax')
])
print("슝~")
# -
model.summary()
# +
import numpy as np
image = np.array([[1, 2], [3, 4]])
print(image.shape)
image
# -
image.flatten()
# ## 14-6. 내가 직접 만드는 강아지 고양이 분류기 (5) 모델아 모델아, 데이터를 먹고 똑똑해지렴!
# +
learning_rate = 0.0001
model.compile(optimizer=tf.keras.optimizers.RMSprop(learning_rate=learning_rate),
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=['accuracy'])
print("슝~")
# -
BATCH_SIZE = 32
SHUFFLE_BUFFER_SIZE = 1000
print("슝~")
train_batches = train.shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE)
validation_batches = validation.batch(BATCH_SIZE)
test_batches = test.batch(BATCH_SIZE)
print("슝~")
# +
for image_batch, label_batch in train_batches.take(1):
break
image_batch.shape, label_batch.shape
# +
validation_steps = 20
loss0, accuracy0 = model.evaluate(validation_batches, steps=validation_steps)
print("initial loss: {:.2f}".format(loss0))
print("initial accuracy: {:.2f}".format(accuracy0))
# -
EPOCHS = 10
history = model.fit(train_batches,
epochs=EPOCHS,
validation_data=validation_batches)
# ## 14-7. 내가 직접 만드는 강아지 고양이 분류기 (6) 모델은 얼마나 똑똑해졌을까? 확인해 보자!
# +
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss=history.history['loss']
val_loss=history.history['val_loss']
epochs_range = range(EPOCHS)
plt.figure(figsize=(12, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend()
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend()
plt.title('Training and Validation Loss')
plt.show()
# +
for image_batch, label_batch in test_batches.take(1):
images = image_batch
labels = label_batch
predictions = model.predict(image_batch)
break
predictions
# -
predictions = np.argmax(predictions, axis=1)
predictions
# +
plt.figure(figsize=(20, 12))
for idx, (image, label, prediction) in enumerate(zip(images, labels, predictions)):
plt.subplot(4, 8, idx+1)
image = (image + 1) / 2
plt.imshow(image)
correct = label == prediction
title = f'real: {label} / pred :{prediction}\n {correct}!'
if not correct:
plt.title(title, fontdict={'color': 'red'})
else:
plt.title(title, fontdict={'color': 'blue'})
plt.axis('off')
# +
count = 0 # 정답을 맞춘 개수
for image, label, prediction in zip(images, labels, predictions):
# [[YOUR CODE]]
correct = label == prediction # 정답 == 예측
if correct:
count += 1
print(count / 32 * 100)
# -
# ## 14-8. 내가 직접 만들지 않고 가져다 쓰는 강아지 고양이 분류기 (1) 어려운 문제는 직접 풀지 말자, 똑똑한 누군가가 이미 풀어놨을 테니!
# ## 14-9. 내가 직접 만들지 않고 가져다 쓰는 강아지 고양이 분류기 (2) 아주 똑똑한 모델을 간단히 가져오는 방법
# +
IMG_SHAPE = (IMG_SIZE, IMG_SIZE, 3)
# Create the base model from the pre-trained model VGG16
base_model = tf.keras.applications.VGG16(input_shape=IMG_SHAPE,
include_top=False,
weights='imagenet')
# -
image_batch.shape
feature_batch = base_model(image_batch)
feature_batch.shape
base_model.summary()
# ## 14-10. 내가 직접 만들지 않고 가져다 쓰는 강아지 고양이 분류기 (3) 모델의 마지막 부분만, 내 입맛대로 재구성하기
feature_batch.shape
# +
import numpy as np
image = np.array([[1, 2],
[3, 4]])
flattened_image = image.flatten()
print("Original image:\n", image)
print("Original image shape:", image.shape)
print()
print("Flattened image:\n", flattened_image)
print("Flattened image shape:", flattened_image.shape)
# -
global_average_layer = tf.keras.layers.GlobalAveragePooling2D()
print("슝~")
feature_batch_average = global_average_layer(feature_batch)
print(feature_batch_average.shape)
# +
dense_layer = tf.keras.layers.Dense(512, activation='relu')
prediction_layer = tf.keras.layers.Dense(2, activation='softmax')
# feature_batch_averag가 dense_layer를 거친 결과가 다시 prediction_layer를 거치게 되면
prediction_batch = prediction_layer(dense_layer(feature_batch_average))
print(prediction_batch.shape)
# -
base_model.trainable = False
print("슝~")
model = tf.keras.Sequential([
base_model,
global_average_layer,
dense_layer,
prediction_layer
])
print("슝~")
model.summary()
# ## 14-11. 내가 직접 만들지 않고 가져다 쓰는 강아지 고양이 분류기 (4) 거인의 어깨에 올라타서 예측하니, 더 잘 예측할 수밖에!
base_learning_rate = 0.0001
model.compile(optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate),
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=['accuracy'])
# +
validation_steps=20
loss0, accuracy0 = model.evaluate(validation_batches, steps = validation_steps)
print("initial loss: {:.2f}".format(loss0))
print("initial accuracy: {:.2f}".format(accuracy0))
# +
EPOCHS = 5 # 이번에는 이전보다 훨씬 빠르게 수렴되므로 5Epoch이면 충분합니다.
history = model.fit(train_batches,
epochs=EPOCHS,
validation_data=validation_batches)
# +
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.figure(figsize=(16, 8))
plt.subplot(1, 2, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1])
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([0,1.0])
plt.title('Training and Validation Loss')
plt.xlabel('epoch')
plt.show()
# +
for image_batch, label_batch in test_batches.take(1):
images = image_batch
labels = label_batch
predictions = model.predict(image_batch)
pass
predictions
# -
import numpy as np
predictions = np.argmax(predictions, axis=1)
predictions
# +
plt.figure(figsize=(20, 12))
for idx, (image, label, prediction) in enumerate(zip(images, labels, predictions)):
plt.subplot(4, 8, idx+1)
image = (image + 1) / 2
plt.imshow(image)
correct = label == prediction
title = f'real: {label} / pred :{prediction}\n {correct}!'
if not correct:
plt.title(title, fontdict={'color': 'red'})
else:
plt.title(title, fontdict={'color': 'blue'})
plt.axis('off')
# +
count = 0
for image, label, prediction in zip(images, labels, predictions):
correct = label == prediction
if correct:
count = count + 1
print(count / 32 * 100) # 약 95% 내외
# -
# ## 14-12. 내가 직접 만들지 않고 가져다 쓰는 강아지 고양이 분류기 (5) 잘 학습된 모델은 저장해두고, 언제든 꺼내 쓰도록 하자!
# ```bash
# $ mkdir -p ~/aiffel/cat_vs_dog
# $ mkdir -p ~/aiffel/cat_vs_dog/checkpoint
# $ mkdir -p ~/aiffel/cat_vs_dog/images
# ```
# +
import os
checkpoint_dir = os.getenv("HOME") + "/aiffel/cat_vs_dog/checkpoint"
checkpoint_file_path = os.path.join(checkpoint_dir, 'checkpoint')
if not os.path.exists('checkpoint_dir'):
os.mkdir('checkpoint_dir')
model.save_weights(checkpoint_file_path) # checkpoint 파일 생성
if os.path.exists(checkpoint_file_path):
print('checkpoint 파일 생성 OK!!')
# -
# ## 14-13. 내가 직접 만들지 않고 가져다 쓰는 강아지 고양이 분류기 (6) 거울아 거울아, 나는 멍멍이 상이니, 아니면 냥이 상이니?
img_dir_path = os.getenv("HOME") + "/aiffel/cat_vs_dog/images"
os.path.exists(img_dir_path)
from tensorflow.keras.preprocessing.image import load_img, img_to_array
# +
IMG_SIZE = 160
dog_image_path = os.path.join(img_dir_path, 'my_dog.jpeg')
dog_image = load_img(dog_image_path, target_size=(IMG_SIZE, IMG_SIZE))
dog_image
# -
dog_image = img_to_array(dog_image).reshape(1, IMG_SIZE, IMG_SIZE, 3)
dog_image.shape
prediction = model.predict(dog_image)
prediction
def show_and_predict_image(dirpath, filename, img_size=160):
filepath = os.path.join(dirpath, filename)
image = load_img(filepath, target_size=(img_size, img_size))
plt.imshow(image)
plt.axis('off')
image = img_to_array(image).reshape(1, img_size, img_size, 3)
prediction = model.predict(image)[0]
cat_percentage = round(prediction[0] * 100)
dog_percentage = round(prediction[1] * 100)
print(f"This image seems {dog_percentage}% dog, and {cat_percentage}% cat.")
# +
filename = 'my_dog.jpeg'
show_and_predict_image(img_dir_path, filename)
# +
filename = 'my_cat.jpeg'
show_and_predict_image(img_dir_path, filename)
# -
filename = "my_cat.jpeg"
show_and_predict_image(img_dir_path, filename)
# ## 14-14. 프로젝트: 새로운 데이터셋으로 나만의 이미지 분류기 만들어보기
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] slideshow={"slide_type": "slide"}
# # Model Balance and Feature Importance
#
# 1. Classification models with imbalanced data
# 1. Visualizing trees
# 1. Feature importance
#
# As I said last class, the main drawback with ensembles is usually imbalanced classification and interpretation.
#
# + slideshow={"slide_type": "notes"}
# import lots of functions
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer, make_column_selector
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.impute import SimpleImputer
from df_after_transform import df_after_transform
from sklearn.model_selection import KFold, cross_validate, GridSearchCV
from sklearn.metrics import confusion_matrix
# + slideshow={"slide_type": "notes"}
# load data
loans = pd.read_csv('lendingclub/2013_subsample.zip')
# + slideshow={"slide_type": "notes"}
# split to test and train (link to split page/sk docs)
# first let's separate y from X
y = loans.loan_status == 'Charged Off'
y.value_counts()
loans = loans.drop('loan_status',axis=1)
# stratify will make sure that test/train both have equal fractions of outcome
X_train, X_test, y_train, y_test = train_test_split(loans, y, stratify=y, test_size=.2, random_state=0)
# + slideshow={"slide_type": "notes"}
## optimize a series of models
# set up pipeline to clean each type of variable (1 pipe per var type)
numer_pipe = make_pipeline(SimpleImputer(),StandardScaler())
cat_pipe = make_pipeline(OneHotEncoder(drop='first'))
# combine those pipes into "preprocess" pipe
preproc_pipe = ColumnTransformer(
[ # arg 1 of ColumnTransformer is a list, so this starts the list
# a tuple for the numerical vars: name, pipe, which vars to apply to
("num_impute", numer_pipe, ['annual_inc']),
# a tuple for the categorical vars: name, pipe, which vars to apply to
("cat_trans", cat_pipe, ['grade'])
]
, remainder = 'drop' # you either drop or passthrough any vars not modified above
)
# + [markdown] slideshow={"slide_type": "subslide"}
# Like last lecture, I've imported the Lending Club data.
#
# Like all real datasets, its outcome variable is imbalanced.
# + slideshow={"slide_type": "fragment"}
y_train.value_counts(normalize=True).round(3)
# + [markdown] slideshow={"slide_type": "subslide"}
# ## Ways to deal with imbalanced data
#
# 1. Add data (oversample underrepresented group)
# - Slower estimations (more data)
# 1. Remove data (undersample overrepresented group)
# - Throws data away (hurts predictions!) but estimations faster
# - Tradeoff can be worth it: more speed and possibly similar or better predictions
# 1. Change estimator to "weight" groups equally
# - `class-weight=’balanced’` in trees, logit
# - like oversampling, except no slowdown
# + [markdown] slideshow={"slide_type": "fragment"}
# ### 🔥🔥🔥 Practical tips: 🔥🔥🔥
# - What works best varies between applications (no "dominant")
# - Try weighting if estimator will let you, then undersampling
# + [markdown] slideshow={"slide_type": "slide"}
# ## Examples - dealing with imbalance
#
# So this was last time, predictions of default had a precision of 22%, and only 3% of defaults were predicted in advance. (BAD RECALL!)
# + slideshow={"slide_type": "subslide"}
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report
from sklearn.metrics import plot_confusion_matrix
tree_clf = make_pipeline(preproc_pipe, DecisionTreeClassifier())
tree_clf.fit(X_train, y_train)
tree_clf.predict(X_test).sum() # number of rejections under old model
# print(classification_report(y_test, tree_clf.predict(X_test)) )
# plot_confusion_matrix(tree_clf, X_test, y_test, normalize='pred')
# plt.show()
# + [markdown] slideshow={"slide_type": "slide"}
# ### Class weighting...
#
# ...like oversampling but without increasing the training speed. The tip on dealing with imbalanced data is
#
# > "Try weighting if estimator will let you, then undersampling"
#
# So let's add `class_weight='balanced'` to the Tree.
# + [markdown] slideshow={"slide_type": "subslide"}
# 1. So, how well do we do at predicting loan defaults?
# 1. How "accurate" is our model?
# + slideshow={"slide_type": "fragment"}
tree_clf = make_pipeline(preproc_pipe, DecisionTreeClassifier(class_weight='balanced'))
tree_clf.fit(X_train, y_train)
# print(classification_report(y_test, tree_clf.predict(X_test)) )
# plot_confusion_matrix(tree_clf, X_test, y_test, normalize='pred')
# plt.show()
tree_clf.predict(X_test).sum() # number of rejections under old model
# + [markdown] slideshow={"slide_type": "subslide"}
# So the lessons here:
#
# 1. Beware high accuracy models unless you see the classification report or confusion matrix!
# 1. Depending on the application, a lower accuracy score might be strongly preferred if sensitivity/recall or precision matters.
#
# + [markdown] slideshow={"slide_type": "slide"}
# ### Undersampling (and over)
#
# Undersampling and over sampling can't be done within sklearn pipelines "out of the box", so we will install and use a package that extends the sklearn API.
#
# https://imbalanced-learn.org/
#
# `pip install -U imbalanced-learn`
# + [markdown] slideshow={"slide_type": "subslide"}
# Compare the recall and accuracy to the last class's version without fixes (3% and 83%).
# + slideshow={"slide_type": "fragment"}
# the under sampler
from imblearn.under_sampling import RandomUnderSampler
# sklearn pipelines won't work for sampling - use the imblearn pipeline
# here I name it differently to clarify that it isnt the sklearn make_pipeline
from imblearn.pipeline import make_pipeline as make_imb_pipeline
tree_clf = make_imb_pipeline(RandomUnderSampler(),
preproc_pipe, DecisionTreeClassifier())
tree_clf.fit(X_train, y_train)
print(classification_report(y_test, tree_clf.predict(X_test)) )
plot_confusion_matrix(tree_clf, X_test, y_test, normalize='true')
plt.show()
# + [markdown] slideshow={"slide_type": "subslide"}
# Over sampling is procedurally the same.
#
# In this example, the recall on defaults is a little lower than the undersampling (way to go undersampling!), while most other numbers are slightly higher.
# + slideshow={"slide_type": "fragment"}
from imblearn.over_sampling import RandomOverSampler
tree_clf = make_imb_pipeline(RandomOverSampler(),
preproc_pipe, DecisionTreeClassifier())
tree_clf.fit(X_train, y_train)
print(classification_report(y_test, tree_clf.predict(X_test)) )
plot_confusion_matrix(tree_clf, X_test, y_test, normalize='true')
plt.show()
# + [markdown] slideshow={"slide_type": "slide"}
# ## Visualizing trees
#
# 1. Plotting a tree: `tree.plot_tree(<tree object>)`
# - Good idea: Restrict depth to 3 or so layers, then plot
# - `dtreeviz` is a really nice tree visualizing package
# - Other
# 1. Plot the "decision surface".
# - Can be a pain with real data...
# + slideshow={"slide_type": "subslide"}
# i'm just changing this to only use 2 numerical values
preproc_pipe = ColumnTransformer([("num_impute", numer_pipe, ['annual_inc','dti'])]
, remainder = 'drop')
# only do tree to 2 levels
tree_clf = make_pipeline(preproc_pipe,
DecisionTreeClassifier(class_weight='balanced',
max_depth=2))
tree_clf.fit(X_train, y_train)
from sklearn import tree
fig, ax = plt.subplots(figsize=(12,8))
tree.plot_tree(tree_clf['decisiontreeclassifier'], ax=ax,
filled=True,feature_names = ['annual_inc','dti'],
class_names = ['Repaid','Charge Off'])
plt.show()
# + slideshow={"slide_type": "notes"}
from df_after_transform import df_after_transform
import numpy as np
X = df_after_transform(preproc_pipe,X_train)
y = y_train.copy() # from https://scikit-learn.org/stable/auto_examples/tree/plot_iris_dtc.html
# + slideshow={"slide_type": "subslide"} tags=["remove-input", "hide-input"]
n_classes = 2
# define bounds of the domain
min1, max1 = X.iloc[:, 0].min()-1, X.iloc[:, 0].max()+1
min2, max2 = X.iloc[:, 1].min()-1, X.iloc[:, 1].max()+1
# define the x and y scale
x1grid = np.arange(min1, max1, 0.1)
x2grid = np.arange(min2, max2, 0.1)
# create all of the lines and rows of the grid
xx, yy = np.meshgrid(x1grid, x2grid)
# flatten each grid to a vector
r1, r2 = xx.flatten(), yy.flatten()
r1, r2 = r1.reshape((len(r1), 1)), r2.reshape((len(r2), 1))
# horizontal stack vectors to create x1,x2 input for the model
grid = np.hstack((r1,r2))
# define the model
model = tree_clf
# fit the model
model.fit(X, y)
# make predictions for the grid
yhat = model.predict(pd.DataFrame(grid,columns=['annual_inc','dti']))
# reshape the predictions back into a grid
zz = yhat.reshape(xx.shape)
# plot the grid of x, y and z values as a surface
plt.contourf(xx, yy, zz, cmap='Paired')
# create scatter plot for samples from each class
# Plot the training points
for i, color in zip(range(n_classes), "rb"):
idx = np.where(y == i)
plt.scatter(X.values[idx, 0], X.values[idx, 1], c=color,
cmap=plt.cm.RdYlBu, edgecolor='black', s=15) #label=iris.target_names[i],
plt.show()
# + [markdown] slideshow={"slide_type": "slide"}
# ## Feature importance
#
# - One way to visualize importance
# - Akin to looking at top levels of a tree
# - Caution
# +
tree_clf = make_pipeline(preproc_pipe, DecisionTreeClassifier())
tree_clf.fit(X_train, y_train)
importances = tree_clf['decisiontreeclassifier'].feature_importances_
importances = pd.DataFrame(importances,
index=df_after_transform(preproc_pipe,X_train).columns
)
importances
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# Поключаем пакеты для ML
import math
import json
from typing import Tuple
import matplotlib
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib import patches
import numpy as np
import pandas as pd
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_percentage_error
from sklearn.metrics import precision_score, recall_score, f1_score
from sklearn.tree import DecisionTreeRegressor
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.neural_network import MLPClassifier
from sklearn.linear_model import LinearRegression, LogisticRegression
from catboost import CatBoostClassifier
import tensorflow as tf
from tensorflow import keras
from tensorflow import keras
from tensorflow.python.keras import engine
from tensorflow.keras import layers
import seaborn as sns
from scipy import stats
# -
with open('../regression_model/data/train.json') as json_file:
simulation_data = json.load(json_file)
simulation_data = pd.DataFrame.from_dict(simulation_data)
simulation_data
COLUMNS = [
'num_stations',
'queue_capacity',
'mean_arrival_time',
'std_arrival_time',
'bitrate',
'mean_packet_size',
'std_mean_packet_size',
]
simulation_data
train_data, test_data, y_train, y_test = train_test_split(
simulation_data, simulation_data.loc[:, 'e2e_delay'],
test_size=0.33,
random_state=42)
x_train = train_data.loc[:, COLUMNS]
x_test = test_data.loc[:, COLUMNS]
# ### МЕТРИКИ
# Для оценки полученных моделей нам будут необходимы метрики, а именно:
#
# - Стандартное отклонение
def std(x: np.ndarray, y: np.ndarray) -> float:
"""
Standard deviation between simulation model
values and estimates
"""
return math.sqrt(np.sum((x-y)**2) / (len(x) - 1))
# - Коэффициент корреляции
def corr(x: np.ndarray, y: np.ndarray) -> float:
"""
Correlation coefficient between simulation model
values and estimate
"""
r = np.corrcoef(x, y)
return r[0,1]
# - среднеквадратичная ошибка;
#
# ```sklearn.metrics.mean_squared_error ```.
# - и коэффициент детерминации.
#
# ```sklearn.metrics.r2_score```.
# ### Приступим непосредственно к обучению
#
# - ## Задача регресии МНК
"""Prepare regression model using Least Squares algorithm"""
def get_ls_regression_model(x_train, x_test,
y_train, y_test) -> (np.ndarray,
LinearRegression):
ls = LinearRegression()
# ls = Ridge(alpha=.5)
ls.fit(x_train, y_train)
ls_y = ls.predict(x_test)
return ls_y, ls
ls_delay_estimate, ls = get_ls_regression_model(x_train,
x_test,
y_train,
y_test)
print(f'R = {corr(y_test, ls_delay_estimate):.3f}')
print(f'STD = {std(y_test, ls_delay_estimate):.3f}')
print(f'MSE = {mean_squared_error(y_test, ls_delay_estimate):.3f}')
print(f'R2 = {r2_score(y_test, ls_delay_estimate):.3f}')
print(f'MAPE = {mean_absolute_percentage_error(y_test, ls_delay_estimate):.3f}')
# DataFrame для отриосвки графиков
draw_data = test_data
draw_data.loc[:, 'LsDelayEst'] = ls_delay_estimate
draw_data['num_stations'].unique()
# - ## Задача регресии на дереве решений
"""Prepare regression model using Decision Tree algorithm"""
def get_tree_regression_model(x_train, x_test,
y_train, y_test,
max_depth=36,
splitter='best') -> (np.ndarray, DecisionTreeRegressor):
tree_reg = DecisionTreeRegressor(max_depth=max_depth, splitter=splitter)
tree_reg.fit(x_train, y_train)
tree_y = tree_reg.predict(x_test)
# print(f'R = {corr(y_test, tree_y):.3f}')
# print(f'STD = {std(y_test, tree_y):.3f}')
# print(f'MSE = {mean_squared_error(y_test, tree_y):.3f}')
return tree_y, tree_reg
tree_delay_estimate, tree_reg = get_tree_regression_model(x_train,
x_test,
y_train,
y_test)
print(f'R = {corr(y_test, tree_delay_estimate,):.3f}')
print(f'STD = {std(y_test, tree_delay_estimate,):.3f}')
print(f'MSE = {mean_squared_error(y_test, tree_delay_estimate,):.3f}')
print(f'R2 = {r2_score(y_test, tree_delay_estimate,):.3f}')
print(f'MAPE = {mean_absolute_percentage_error(y_test, tree_delay_estimate):.3f}')
draw_data.loc[:, 'TreeDelayEst'] = tree_delay_estimate
# - ## Задача регрессии с помощью градиентного бустинга на деревьях решений
"""Prepare regression model using Gradient Boosting algorithm"""
def get_gtb_regression_model(x_train, x_test,
y_train, y_test,
n_estimators=100,
learning_rate=.1,
max_depth=10) -> (np.ndarray, GradientBoostingRegressor):
gtb = GradientBoostingRegressor(n_estimators=n_estimators,
learning_rate=learning_rate,
max_depth=max_depth)
gtb.fit(x_train, y_train)
gtb_y = gtb.predict(x_test)
return gtb_y, gtb
gtb_delay_estimate, gtb = get_tree_regression_model(x_train,
x_test,
y_train,
y_test)
print(f'R = {corr(y_test, gtb_delay_estimate,):.3f}')
print(f'STD = {std(y_test, gtb_delay_estimate,):.3f}')
print(f'MSE = {mean_squared_error(y_test, gtb_delay_estimate,):.3f}')
print(f'R2 = {r2_score(y_test, gtb_delay_estimate,):.3f}')
print(f'MAPE = {mean_absolute_percentage_error(y_test, gtb_delay_estimate):.3f}')
draw_data.loc[:, 'GTBDelayEst'] = gtb_delay_estimate
# - ## Задача регрессии с помощью искуственной нейронной сети на алгоритме Adam
#
def normalize(table, stat) -> pd.core.frame.DataFrame:
"""Prepare data for ANN"""
return (table - stat.loc['mean',:].transpose()) / stat.loc['std',:].transpose()
train_normalize = normalize(x_train, simulation_data.loc[:,COLUMNS].describe())
train_normalize.to_numpy();
test_normalize = normalize(x_test, simulation_data.loc[:,COLUMNS].describe())
test_normalize.to_numpy();
train_normalize['queue_capacity'] = 1
test_normalize['queue_capacity'] = 1
# +
def build_model(size, activation='sigmoid') -> np.ndarray:
model = keras.Sequential([
# Input Layer
# layers.Dense(18, activation=activation,
# use_bias=True, input_shape=[size]),
layers.Flatten(input_shape=[size]),
# Hidden Layer
layers.Dense(14, activation=activation, use_bias=True),
# Output layer
layers.Dense(1)])
optimizer = tf.keras.optimizers.Adam(0.01)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mse'])
print(model.summary())
return model
def get_ann_regression_model(train_normalize,
test_normalize,
y_train_ann, y_test_ann,
size,
epochs=1000,
activation='sigmoid') -> Tuple[np.ndarray,
engine.sequential.Sequential]:
ann = build_model(size=size)
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
EPOCHS = epochs
keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
ann.fit(train_normalize, y_train_ann, epochs=EPOCHS, validation_split=0.3, verbose=0,
callbacks=[keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)])
ann_y = ann.predict(test_normalize).flatten();
return ann_y, ann
# -
# %%time
ann_delay_estimate, ann = get_ann_regression_model(train_normalize,
test_normalize,
y_train, y_test,
size=len(simulation_data.loc[:,COLUMNS].keys()))
print(f'R = {corr(y_test, ann_delay_estimate):.3f}')
print(f'STD = {std(y_test, ann_delay_estimate):.3f}')
print(f'MSE = {mean_squared_error(y_test, ann_delay_estimate):.3f}')
print(f'R2 = {r2_score(y_test, ann_delay_estimate):.3f}')
print(f'MAPE = {mean_absolute_percentage_error(y_test, ann_delay_estimate):.3f}')
# Добавим в draw_data оценку ann_y
draw_data['AnnDelayEst'] = ann_delay_estimate
# +
model = [ls_delay_estimate,
tree_delay_estimate,
gtb_delay_estimate,
ann_delay_estimate]
label = ['Least Squeare model',
'Decision tree model',
'Gradient Boosting model',
'Neural network model']
column = ['LsDelayEst',
'TreeDelayEst',
'GTBDelayEst',
'AnnDelayEst']
scatter_color = ['Greens',
'autumn',
'Blues',
'PuRd']
diag_line_color = ['aquamarine',
'red',
'dodgerblue',
'pink']
fig = plt.figure(figsize=(18, 18))
plt.subplots_adjust(top=0.92)
fig.suptitle('E2E Delay', fontsize=28, fontweight='bold')
x = np.linspace(0,20,10)
for i in range(4):
ax = fig.add_subplot(2, 2, i+1)
ax.set_title(label[i], fontdict={'fontweight': 'bold'})
cm = plt.get_cmap(scatter_color[i])
col = [cm(float(i)/(len(ann_delay_estimate))) for i in range((len(ann_delay_estimate)))]
ax = plt.scatter(draw_data[column[i]], y_test, c=col)
# plt.subplots_adjust(top=0.95)
plt.plot(x, x,
linestyle='-',
linewidth=2.4,
color=diag_line_color[i])
# plt.xlim([0, 800])
# plt.ylim([0, 800])
plt.xlabel(r'$Delay \ Test$')
plt.ylabel(r'$Delay \ Estimate$')
plt.grid()
# plt.savefig('data/images/total_scatter_diagram.pdf')
# -
draw_data
plt.scatter(draw_data['AnnDelayEst'],
y_test,
c=col)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
item_cats = pd.read_csv("../data/item_categories.csv")
items = pd.read_csv("../data/items.csv")
shops = pd.read_csv("../data/shops.csv")
sample_sub = pd.read_csv("../data/sample_submission.csv")
sales_train = pd.read_csv("../data/sales_train.csv")
test = pd.read_csv("../data/test.csv")
item_cats.head()
items.head()
shops.head()
sample_sub.head()
sales_train.head()
test.head()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
# ### SET 1
list1 = [24.23,25.53,25.41,24.14,29.62,28.25,25.81,24.39,40.26,32.95,91.36,25.99,39.42,26.71,35.00]
plt.boxplot(list1);
sns.distplot(list1)
np.mean(list1)
np.std(list1)
np.var(list1)
# ### SET 4
# Question 3
1 - (stats.norm.cdf(55,50,4)-stats.norm.cdf(45,50,4))
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ##Exercises obtained from Kaggle: Pandas mini courses
# Here:https://www.kaggle.com/residentmario/renaming-and-combining
# +
import pandas as pd
reviews = pd.read_csv("winemag-data-130k-v2.csv", index_col=0)
# -
# region_1 and region_2 are pretty uninformative names for locale columns in the dataset. Create a copy of reviews with these columns renamed to region and locale, respectively.
renamed = reviews.rename(columns={'region_1':'region','region_2':'locale'})
renamed.head()
# Set the index name in the dataset to wines.
reindexed = reviews.rename_axis("wines",axis='rows')
reindexed.head()
# The Things on Reddit dataset includes product links from a selection of top-ranked forums ("subreddits") on reddit.com. Run the cell below to load a dataframe of products mentioned on the /r/gaming subreddit and another dataframe for products mentioned on the r//movies subreddit.
gaming_products = pd.read_csv("gaming.csv")
gaming_products['subreddit'] = "r/gaming"
movie_products = pd.read_csv("movies.csv")
movie_products['subreddit'] = "r/movies"
# Create a DataFrame of products mentioned on either subreddit.
combined_products = pd.concat([gaming_products, movie_products])
combined_products
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # TEXT MINING for PRACTICE: Matplotlib
# ---
# +
import matplotlib.pyplot as plt
# 주피터 노트북에서 사용시 아래의 명령어를 추가
# %matplotlib inline
# -
# ## 1. 기초
# +
import numpy as np
x = np.linspace(1, 10, 50) #n
a = np.log(x) #logn
b = x ** 2 #n^2
c = np.log(x)*x #nlogn
d = 2**x #2
# -
# 'r' 은 색깔 (red)
plt.plot(x, a, 'r')
plt.xlabel('X Axis')
plt.ylabel('Y Axis')
plt.title('Title')
plt.show()
# +
# plt.subplot(nrows, ncols, plot_number)
plt.subplot(1,3,1)
plt.plot(x, b, 'r*-');
plt.subplot(1,3,2)
plt.plot(x, c, 'b--');
plt.subplot(1,3,3)
plt.plot(x, d, 'g+-');
# 모양이 간격이 좀 안 맞는다 싶으면,
#plt.tight_layout()
# +
#한 차트에 여러 그래프
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.plot(x, a, label="logN")
ax.plot(x, b, label="N^2")
ax.plot(x, c, label="NlogN")
ax.plot(x, d, label="2^N")
ax.legend()
# +
# 차트 내부에 차트를 넣고 싶다면
fig = plt.figure()
ax1 = fig.add_axes([0,0,1,1])
ax2 = fig.add_axes([0.1,0.4,0.3,0.3])
ax1.plot(x, a, label="logN")
ax1.plot(x, b, label="N^2")
ax1.legend()
ax2.plot(x, c, label="NlogN")
ax2.plot(x, d, label="2^N")
ax2.legend()
# +
# 특정 구간으로 그래프를 제한하고 싶다면
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.set_title("Title")
ax.plot(x, a, label="logN")
ax.plot(x, b, label="N^2")
ax.plot(x, c, label="NlogN")
ax.plot(x, d, label="2^N")
ax.set_ylim([0,100])
ax.set_xlim([3,7])
ax.legend()
# -
# ## 2. 한국어 폰트 설정
# 나눔고딕 폰트는 [여기서](https://hangeul.naver.com/download.nhn#sc_ng) 다운 받을 수 있습니다.
import matplotlib.font_manager as fm
# '나눔' 이라는 단어가 들어간 폰트 확인
f = [f for f in fm.fontManager.ttflist if 'nanum' in f.name.lower()]
print(f)
# +
plt.rcParams["font.family"] = 'NanumGothic'
plt.rcParams['font.size'] = 10.
plt.rcParams['xtick.labelsize'] = 10.
plt.rcParams['ytick.labelsize'] = 10.
plt.rcParams['axes.labelsize'] = 10.
fig, ax = plt.subplots()
# Example data
people = ['손흥민', '류현진', '김연아', '박지성', 'BTS']
y_pos = np.arange(len(people))
performance = 3 + 10 * np.random.rand(len(people))
error = np.random.rand(len(people))
ax.barh(y_pos, performance, xerr=error, align='center',
color='green', ecolor='black')
ax.set_yticks(y_pos)
ax.set_yticklabels(people)
ax.invert_yaxis() # labels read top-to-bottom
ax.set_xlabel('투표결과')
ax.set_title('누가 한국을 빛냈는가?')
plt.show()
# -
# ## 3. 다른 차트들
# 코드는 [여기서](https://matplotlib.org/gallery/index.html) 찾을 수 있습니다.
# +
fig, ax = plt.subplots()
for color in ['red', 'green', 'blue']:
n = 750
x, y = np.random.rand(2, n)
scale = 200.0 * np.random.rand(n)
ax.scatter(x, y, c=color, s=scale, label=color,
alpha=0.3, edgecolors='none')
ax.legend()
ax.grid(True)
plt.show()
# +
N_points = 100000
n_bins = 20
# Generate a normal distribution, center at x=0 and y=5
x = np.random.randn(N_points)
y = .4 * x + np.random.randn(100000) + 5
fig, axs = plt.subplots(1, 2, sharey=True)
# We can set the number of bins with the `bins` kwarg
axs[0].hist(x, bins=n_bins)
axs[1].hist(y, bins=n_bins)
# -
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# ## Introduction to Psychsim
# Psychsim is a tool for constructing and simulating social scenarios rapidly. It is an implementation of the Partially Observable Markov Decision Process (POMDP), and allows rational agents to make decisions. In this tutorial, we build a maze in a 2D grid world, and create an agent that can solve the maze. The maze is 5 tiles by 5 tiles in size with many obstacles blocking the path.
#
# This scenario can be visualized by running demo.py code, which requires the pyglet graphics library.
#
#
# Begin by importing the Psychsim modules:
from psychsim.reward import *
from psychsim.pwl import *
from psychsim.action import *
from psychsim.world import *
from psychsim.agent import *
# ## Creating an Agent
# First, define and create a world as the setting for the scenario. Then, create some agent, give it a name, and set the number of steps it looks ahead (horizon). That agent has to be added to the world to act.
world = World()
actor = Agent('Agent')
actor.setHorizon(5)
world.addAgent(actor)
print(world.agents.keys())
# ## Defining the Agent States
# An agent can have states, which can be defined in the world with the agent's name, the state's name, and the type. In the grid world, we define the agent's x and y coordinate as states, and the coordinate of the end of the maze.
world.defineState(actor.name,'x',int)
world.defineState(actor.name,'y',int)
world.defineState(actor.name, 'goal_x', int)
world.defineState(actor.name, 'goal_y', int);
# We can also set the initial values for the states, and access them. In a fully-observable deterministic model, probability of a state is 100%.
# +
world.setState(actor.name, 'x', 0)
world.setState(actor.name, 'y', 0)
world.setState(actor.name, 'goal_x', 5)
world.setState(actor.name, 'goal_y', 5)
print('x: ' + str(world.getState(actor.name,'x')) + ' , y: ' + str(world.getState(actor.name,'y')))
print('goal x: ' + str(world.getState(actor.name,'goal_x')) + ' , goal y: ' + str(world.getState(actor.name,'goal_y')))
# -
# Next, we define a list of obstacles in the maze that the agent needs to move around.
obstacles = [(0,1),(0,2),(0,3),(1,3),(2,3),(3,3),(4,3),(4,2),(4,1),(2,1),(2,0)]
# ## Define the Agent Actions
# In the grid world, the agent can only move right, left, up, and down. We can add these actions to the agent. Additionally, each action has some effect on the world dynamics. For example, if the agent moves right, its x-coordinate increases by one. We have to create a decision tree for these actions and their effect on the world for the decision-making process.
# +
move_right = actor.addAction({'verb': 'MoveRight'})
tree = makeTree(incrementMatrix(stateKey(move_right['subject'], 'x'), 1.))
world.setDynamics(stateKey(move_right['subject'], 'x'), move_right, tree)
move_left = actor.addAction({'verb': 'MoveLeft'})
tree = makeTree(incrementMatrix(stateKey(move_left['subject'], 'x'), -1.))
world.setDynamics(stateKey(move_left['subject'], 'x'), move_left, tree)
move_up = actor.addAction({'verb': 'MoveUp'})
tree = makeTree(incrementMatrix(stateKey(move_up['subject'], 'y'), 1.))
world.setDynamics(stateKey(move_up['subject'], 'y'), move_up, tree)
move_down = actor.addAction({'verb': 'MoveDown'})
tree = makeTree(incrementMatrix(stateKey(move_down['subject'], 'y'), -1.))
world.setDynamics(stateKey(move_down['subject'], 'y'), move_down, tree)
# -
# ## Determining the Legality of Actions
# Next, we have to determine the legality of the agent's actions when it comes to obstacles. The agent cannot move outside of the map's boundaries and certainly not onto the obstacles themselves. To set the legality of these actions, we need to build a decision tree that checks the agent's states compared to some value. The tree is the legality of the "move right" action, with respect to two obstacles on the map. With an increased number of obstacles, the trees get more complicated.
# <img src="files/decisiontree.png">
# Recursive function calls that check the x and y values of the agent's current location against the list of obstacles:
# +
def add_branch_plus_x(i):
if i == -1:
return True
else:
return {'if': equalRow(stateKey(actor.name, 'x'), obstacles[i][0]-1), True: {'if': equalRow(stateKey(actor.name, 'y'), obstacles[i][1]),True: False, False: add_branch_plus_x(i-1)}, False: add_branch_plus_x(i-1)}
def add_branch_minus_x(i):
if i == -1:
return True
else:
return {'if': equalRow(stateKey(actor.name, 'x'), obstacles[i][0]+1), True: {'if': equalRow(stateKey(actor.name, 'y'), obstacles[i][1]),True: False, False: add_branch_minus_x(i-1)}, False: add_branch_minus_x(i-1)}
def add_branch_plus_y(i):
if i == -1:
return True
else:
return {'if': equalRow(stateKey(actor.name, 'y'), obstacles[i][1]-1), True: {'if': equalRow(stateKey(actor.name, 'x'), obstacles[i][0]),True: False, False: add_branch_plus_y(i-1)}, False: add_branch_plus_y(i-1)}
def add_branch_minus_y(i):
if i == -1:
return True
else:
return {'if': equalRow(stateKey(actor.name, 'y'), obstacles[i][1]+1), True: {'if': equalRow(stateKey(actor.name, 'x'), obstacles[i][0]),True: False, False: add_branch_minus_y(i-1)}, False: add_branch_minus_y(i-1)}
# -
# Moving right is invalid if:<br>
# 1) agent's x+1 = obstacle's x and agent's y = obstacle's y<br>
# 2) agent's x = 5, which is the rightmost map boundary.<br>
tree = makeTree({'if': equalRow(stateKey(actor.name, 'x'), '5'),
True: False, False: add_branch_plus_x(len(obstacles)-1)})
actor.setLegal(move_right, tree)
# Moving left is invalid if:<br>
# 1) agent's x-1 = obstacle's x and agent's y = obstacle's y<br>
# 2) agent's x = 0, which is the leftmost map boundary.<br>
tree = makeTree({'if': equalRow(stateKey(actor.name, 'x'), '0'),
True: False, False: add_branch_minus_x(len(obstacles)-1)})
actor.setLegal(move_left, tree)
# Moving up is invalid if:<br>
# 1) agent's y+1 = obstacle's y and agent's x = obstacle's x<br>
# 2) agent's y = 5, which is the topmost map boundary.<br>
tree = makeTree({'if': equalRow(stateKey(actor.name, 'y'), '5'),
True: False, False: add_branch_plus_y(len(obstacles)-1)})
actor.setLegal(move_up, tree)
# Moving down is invalid if:<br>
# 1) agent's y-1 = obstacle's y and agent's x = obstacle's x<br>
# 2) agent's y = 0, which is the bottommost map boundary.<br>
tree = makeTree({'if': equalRow(stateKey(actor.name, 'y'), '0'),
True: False, False: add_branch_minus_y(len(obstacles)-1)})
actor.setLegal(move_down, tree)
# ## Setting the Agent Reward Function
# The rationale for agents to act is on their reward functions. In this example, we take the L1 distance between the agent and the end of the maze as the reward function. The agent's only reward is to minimize the L1 distance, making this a greedy algorithm to reach the end of the maze.
actor.setReward(minimizeDifference(stateKey(actor.name, 'x'), stateKey(actor.name, 'goal_x')), 1.0)
actor.setReward(minimizeDifference(stateKey(actor.name, 'y'), stateKey(actor.name, 'goal_y')), 1.0)
# ## Check for Termination
# When the agent successfully reaches the end of the maze, the world needs to terminate. To create a termination condition, we need to create a decision tree that checks whether the agent's coordinate is the same as its goal coordinate.
tree = makeTree({'if': equalFeatureRow(stateKey(actor.name, 'x'), stateKey(actor.name, 'goal_x')),
True: {'if': equalFeatureRow(stateKey(actor.name, 'y'), stateKey(actor.name, 'goal_y')),
True: True,
False: False},
False: False})
world.addTermination(tree)
# ## Set Turn Order
# In scenarios with multiple agents, the order in which the agents take turns will matter. If all the agents take action at the same time, use parallel. If the agents take turns one after another, then use sequential.
# Parallel action
# world.setOrder([set(world.agents.keys())])
# Sequential action
world.setOrder(world.agents.keys())
# Now, we can run the scenario until termination. At each time step, we can also print the reward for each of the agent's actions.
while not world.terminated():
result = world.step()
world.explain(result,2)
# <img src="files/demo.gif">
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Native deps
# Update to use new pandas call df.explode()
# !pip install --user pandas==0.25
## Downgrade neobolt due to Neo4j getting auth errors
# !pip install --force-reinstall --user \
# neo4j-driver \
# neo4j==1.7.2 neobolt==1.7.9 neotime==1.7.4
import pandas as pd
import graphistry
from neo4j import GraphDatabase
# ## Creds
# +
###graphistry.register(key='AAAA', server='my.graphistry.ngo', protocol='http')
# -
import json
if False:
with open('neo4j.json', 'w') as outfile:
json.dump({ 'uri': "bolt://my.site.ngo:1000", 'user': "neo4j", 'pwd': "my_pwd_here" }, outfile)
# ! cat neo4j.json
NEO4J = { 'uri': "bolt://my.server.ngo:1000", 'auth': ("neo4j", "my_pwd_here") }
if True:
with open('neo4j.json', 'r') as infile:
data = json.load(infile)
NEO4J['uri'] = data['uri']
NEO4J['auth'] = (data['user'], data['pwd'])
#print NEO4J
# ## Setup & Run Neo4j
# Can run the below on a Graphistry server via:
# 1. Copy docker-compose.yml to some folder `neo4j`
# 2. `mkdir` new subfolders under `neo4j/`: `plugins`, `data`, `logs`, `conf`
# 3. Recommended: Copy in the below `neo4j/conf/neo4j.conf`
# 4. Launch via `sudo docker-compose up -d`
# 5. As needed, expose ports 10001-10003 on your instance (e.g., AWS Networking - Security Group: Inbound Rules)
# ! cat neo4j/docker-compose.yml | sed 's#NEO4J_AUTH=neo4j/.*#NEO4J_AUTH=neo4j/my_pwd_here#g'
# ! cat neo4j/conf/neo4j.conf
# ## Install Amass
# +
#### Can skip for Graphistry >= 2.26.2
## ssh -i mykey.pem ubuntu@ec2-1-1...com
## sudo docker exec -it -u root graphistry_notebook_1 bash
## apt install -y zip unzip
# -
#https://github.com/OWASP/Amass/releases
# ! mkdir -p amass/binary
# ! cd amass/binary && wget -O amass.zip "https://github.com/OWASP/Amass/releases/download/v3.4.2/amass_v3.4.2_linux_amd64.zip"
# ! ls -alh amass/binary
# ! cd amass/binary && unzip amass.zip
# ! cd amass/binary && ls -alh
# ! ./amass/binary/amass_v3.4.1_linux_amd64/amass --version
# ## Configure Amass
# ! cat ./amass/config.ini
if True:
with open('./amass/config.ini','w') as file:
file.write("""
#mode = passive
maximum_dns_queries = 500
[domains]
#domain = hotels.com
#domain = expedia.com
#domain = capitalone.com
#domain = jpmorganchase.com
#domain = amazon.com
#domain = google.com
#domain = uber.com
#domain = lyft.com
domain = ca.gov
[resolvers]
resolver = 1.1.1.1 ; Cloudflare
resolver = 8.8.8.8 ; Google
resolver = 64.6.64.6 ; Verisign
resolver = 74.82.42.42 ; Hurricane Electric
resolver = 1.0.0.1 ; Cloudflare Secondary
resolver = 8.8.4.4 ; Google Secondary
resolver = 9.9.9.10 ; Quad9 Secondary
resolver = 64.6.65.6 ; Verisign Secondary
resolver = 77.88.8.1 ; Yandex.DNS Secondary
#[shodan]
#apikey = zzzz
#[gremlin]
#url = wss://zzz.gremlin.cosmos.azure.com:443/
#username = /dbs/amass-test-db/colls/amass-test-graph
#password = zzzz==
""")
# ## Run Amass
# +
# %%time
#amass enum -config data/config.ini -src -log err.log
# ! ./amass/binary/amass_v3.4.2_linux_amd64/amass \
# enum -config ./amass/config.ini \
# -json ./amass/out6_active.json \
# -src -log err.log \
# -timeout 10
# ! ls -alh ./amass
# -
# ## Amass JSON -> Pandas DataFrame
# ! ls ./amass/*.json
# ! wc -l ./amass/out6_active.json
# ! head -n 3 ./amass/out6_active.json
# ! tail -n 3 ./amass/out6_active.json
# %%time
df = pd.read_json('./amass/out6_active.json', lines=True)
print(len(df), len(df.columns), df.columns)
df[:3]
flat_df = df.set_index([c for c in df.columns if c != 'addresses']).explode('addresses').reset_index()
flat_df = pd.concat([flat_df, flat_df['addresses'].apply(pd.Series)], axis=1).drop(columns=['addresses'])
flat_df[:3]
# Entities: domain, name (fqdn), ip, cidr, asn
# Hyperedge connects them, model as one
import graphistry
hg = graphistry.hypergraph(
flat_df.rename(columns={'name': 'fqdn'}),
['domain', 'fqdn', 'ip', 'cidr', 'asn', 'desc'],
direct=True,
opts={
'EDGES': {
'fqdn': ['ip'],
'cidr': ['ip'],
'asn': ['cidr'],
'domain': ['fqdn']
}
})
hg.keys()
## Test
hg['graph'].plot()
# ## Pandas DataFrame to Neo4j
#
# Create & upload a CSV for every node type
# ### Delete DB (<font color="red">CAREFUL!</font>)
if False:
driver = GraphDatabase.driver(**NEO4J)
with driver.session() as session:
tx = session.begin_transaction()
tx.run("MATCH (a)-[r]->(b) DELETE r")
tx.commit()
print('Deleted relns')
with driver.session() as session:
tx = session.begin_transaction()
tx.run("MATCH (a) DELETE a")
tx.commit()
print('Deleted nodes')
# ### Create indexes
# Speeds up merges
# +
for t in hg['graph']._nodes['type'].unique():
print("Index: %s.nodeID" % t)
graphistry.bolt(NEO4J).cypher("""
CREATE CONSTRAINT ON (a:%s) ASSERT a.nodeID IS UNIQUE
""" % t)
### NEO4J ENTERPRISE
#graphistry.bolt(NEO4J).cypher("""
#CREATE CONSTRAINT ON ()-[r:HYPEREDGE]->() ASSERT exists(r.EventID)
#""")
# -
# ### Populate DB
hg['graph']._edges.sample(3)
hg['graph']._nodes.sample(3)
# +
hg['graph']._edges.fillna("").to_csv('/home/graphistry/notebooks/amass/edges.csv', index=False)
for t in hg['graph']._nodes['type'].unique():
hg['graph']._nodes[hg['graph']._nodes['type'] == t].dropna(how='all', axis=1).to_csv('/home/graphistry/notebooks/amass/nodes.%s.csv' % t, index=False)
# ! head -n 3 /home/graphistry/notebooks/amass/edges.csv
# +
def populate_nodes(csv_url, NEO4J, t):
driver = GraphDatabase.driver(**NEO4J)
with driver.session() as session:
session.run("""
USING PERIODIC COMMIT 10000
LOAD CSV WITH HEADERS FROM '""" + csv_url + """' AS row WITH row
MERGE (n:%s { nodeID: row.nodeID })
ON CREATE SET n = row
RETURN n
""" % t.upper())
def populate_relationships(csv_url, NEO4J):
driver = GraphDatabase.driver(**NEO4J)
with driver.session() as session:
session.run("""
USING PERIODIC COMMIT 10000
LOAD CSV WITH HEADERS FROM '""" + csv_url + """' AS row WITH row
MATCH (src { nodeID: row.src })
MATCH (dst { nodeID: row.dst })
MERGE (src)-[r:HYPEREDGE { id: row.EventID }]->(dst)
ON CREATE set r = row
RETURN r
""")
# -
if True:
if True:
for t in hg['graph']._nodes['type'].unique():
populate_nodes(
"file:///notebooks/amass/nodes.%s.csv" % t,
NEO4J,
t)
print('added nodes', len(hg['graph']._nodes))
if True:
populate_relationships(
'file:///notebooks/amass/edges.csv',
NEO4J)
print('added relns', len(hg['graph']._edges))
# ## Test
graphistry.bolt(NEO4J).cypher("""
MATCH (a)-[r { domain: "expedia.com" }]->(b) RETURN a,r,b LIMIT 1000
""").bind(point_title='nodeTitle').plot()
graphistry.bolt(NEO4J).cypher("""
MATCH (a)-[r ]->(b) RETURN a,r,b LIMIT 100000
""").bind(point_title='nodeTitle').plot()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + colab={"base_uri": "https://localhost:8080/"} id="3aSjwrrAQXMJ" executionInfo={"status": "ok", "timestamp": 1617646979370, "user_tz": 180, "elapsed": 607, "user": {"displayName": "Conversion Cockpit", "photoUrl": "", "userId": "03368443523772480822"}} outputId="1b4b5c0f-1c79-4e77-dbfd-ca6eef47c0f7"
from google.colab import drive
from os.path import join
ROOT = "/content/drive"
print(ROOT)
drive.mount(ROOT)
# + colab={"base_uri": "https://localhost:8080/"} id="HFH1B040RWaI" executionInfo={"status": "ok", "timestamp": 1617647008714, "user_tz": 180, "elapsed": 646, "user": {"displayName": "Conversion Cockpit", "photoUrl": "", "userId": "03368443523772480822"}} outputId="ff65d82d-3879-4aff-83c0-42964221b2b4"
# %cd "/content/drive/My Drive/ASR_Repo/self-supervised-speech-recognition"
# + id="H891NcgjQhNv" colab={"base_uri": "https://localhost:8080/"} executionInfo={"status": "ok", "timestamp": 1617648210651, "user_tz": 180, "elapsed": 748, "user": {"displayName": "Conversion Cockpit", "photoUrl": "", "userId": "03368443523772480822"}} outputId="84fdccfe-63b5-42bb-b9b5-f1d031dc542a"
# !git status
# + id="IXC1bwosVt_X" executionInfo={"status": "ok", "timestamp": 1617648190741, "user_tz": 180, "elapsed": 946, "user": {"displayName": "Conversion Cockpit", "photoUrl": "", "userId": "03368443523772480822"}}
# !git config --global user.mail "davimesq@gmail.com"
# !git config --global user.name "davimesq7"
# + id="Bjzz2stSUFfe" executionInfo={"status": "ok", "timestamp": 1617648197649, "user_tz": 180, "elapsed": 1110, "user": {"displayName": "Conversion Cockpit", "photoUrl": "", "userId": "03368443523772480822"}}
# !git add "Teste Notebook.ipynb"
# + colab={"base_uri": "https://localhost:8080/"} id="mf5TwqDoSz1G" executionInfo={"status": "ok", "timestamp": 1617648199824, "user_tz": 180, "elapsed": 679, "user": {"displayName": "Conversion Cockpit", "photoUrl": "", "userId": "03368443523772480822"}} outputId="480ffc60-4f40-4b2e-9bf4-ec795213db16"
# !git commit -m 'teste commit notebook'
# + id="CKxUIawlUItF"
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="sTNeM1IEDYAH" colab_type="text"
# # Generalization
# + [markdown] id="mdYgjGD7DlPD" colab_type="text"
# Generalization is nothing but modeling the network such that it should not overfit the training data and should be able to generalize more precisely the new unseen test data.
#
# This depends on two parameters.
# * complexity of the model
# * performance on training set.
#
# This can be achieved by dividing the given data into two sets. Training set and testing set.
#
# For better performance, divide the training set further into training set and validation set. train the model using the training set and validate the models on the validation sets. choose the model which performs better on the validation set to and test it using the test set.
# + id="ORyORDFNF2lL" colab_type="code" colab={}
from __future__ import print_function
import math
from IPython import display
from matplotlib import cm
from matplotlib import gridspec
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
from sklearn import metrics
# %tensorflow_version 1.x
import tensorflow as tf
from tensorflow.python.data import Dataset
tf.logging.set_verbosity(tf.logging.ERROR)
pd.options.display.max_rows = 10
pd.options.display.float_format = '{:.1f}'.format
# + id="np4buz43F7VY" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 196} outputId="12408643-83d6-472d-959d-48a052654cd6"
california_housing_dataframe = pd.read_csv('https://download.mlcc.google.com/mledu-datasets/california_housing_train.csv', sep=',')
california_housing_dataframe = california_housing_dataframe.reindex(np.random.permutation(california_housing_dataframe.index))
california_housing_dataframe.head()
# + id="SmWe58cnGF6-" colab_type="code" colab={}
def preprocess_features(chd):
'''
chd - califonia housing dataframe
returns - selected features along with syntetic feature in a single df
'''
selected_features = chd[["latitude", "longitude", "housing_median_age", "total_rooms", "total_bedrooms", "population", "households", "median_income"]]
processed_features = selected_features.copy()
processed_features['rooms_per_person'] = chd['total_rooms'] / chd['population']
return processed_features
# + id="HKXm5pDJHudn" colab_type="code" colab={}
def preprocess_targets(chd):
'''
chd - california housing department
returns - target feature as df.
'''
processed_target = pd.DataFrame()
processed_target['median_house_value'] = chd['median_house_value'] / 1000.0
return processed_target
# + id="KeY7pjhoIOd3" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 196} outputId="e69f0c79-6a41-47ce-ad83-164bb0f1aa30"
# training set
training_examples = preprocess_features(california_housing_dataframe.head(12000))
training_examples.head()
training_targets = preprocess_targets(california_housing_dataframe.head(12000))
training_targets.head()
training_examples.head()
# + id="4rntk4ffIvOh" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 196} outputId="86a904d8-0c2f-404d-d588-1b5891e0cbd7"
# validation examples
validation_examples = preprocess_features(california_housing_dataframe.tail(5000))
validation_examples.head()
validation_targets = preprocess_targets(california_housing_dataframe.tail(5000))
validation_targets.head()
# + id="hybTLKZ_K9O3" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 516} outputId="2f51fb48-c0fc-4474-8984-4eebab3d95d2"
# plotting latitude/longitude with median house value as c
plt.figure(figsize=(15,8))
ax = plt.subplot(1,2,1)
ax.set_title('validation sets')
ax.set_autoscaley_on(False)
ax.set_ylim([32, 43])
ax.set_autoscalex_on(False)
ax.set_xlim([-126,-112])
plt.scatter(validation_examples['longitude'], validation_examples['latitude'], cmap='coolwarm', c=(validation_targets['median_house_value']/validation_targets['median_house_value'].max()))
ax = plt.subplot(1,2,2)
ax.set_title('training sets')
ax.set_autoscaley_on(False)
ax.set_ylim([32, 43])
ax.set_autoscalex_on(False)
ax.set_xlim([-126,-112])
plt.scatter(training_examples['longitude'], training_examples['latitude'], cmap='coolwarm', c=(training_targets['median_house_value']/training_targets['median_house_value'].max()))
plt.plot()
# + id="CFo0wjJdRstr" colab_type="code" colab={}
# define input function
def my_input_fn(features, targets, batch_size=1, shuffle=True, epochs=None):
'''
features - input features.
targets - target labels
batch_size - number of batches of examples for training
shuffle - shuffle the examples
epochs - number of times to repeat
'''
features = {key:np.array(value) for key,value in dict(features).items()}
ds = Dataset.from_tensor_slices((features, targets))
ds = ds.batch(batch_size).repeat(epochs)
if shuffle:
ds = ds.shuffle(10000)
features, targets = ds.make_one_shot_iterator().get_next()
return features, targets
# + id="9fOwyZ9mV48U" colab_type="code" colab={}
# since multiple features are used, we need to create a feature column
def feature_column(input_features):
'''returns feature column'''
return set([tf.feature_column.numeric_column(my_feature) for my_feature in input_features])
# + id="XbHHfhz6X4L6" colab_type="code" colab={}
def train_model(learning_rate, steps, batch_size, training_examples, training_targets, validation_examples, validation_targets):
"""Trains a linear regression model of multiple features.
Args:
learning_rate: A `float`, the learning rate.
steps: A non-zero `int`, the total number of training steps. A training step
consists of a forward and backward pass using a single batch.
batch_size: A non-zero `int`, the batch size.
training_examples: A `DataFrame` containing one or more columns from
`california_housing_dataframe` to use as input features for training.
training_targets: A `DataFrame` containing exactly one column from
`california_housing_dataframe` to use as target for training.
validation_examples: A `DataFrame` containing one or more columns from
`california_housing_dataframe` to use as input features for validation.
validation_targets: A `DataFrame` containing exactly one column from
`california_housing_dataframe` to use as target for validation.
Returns:
A `LinearRegressor` object trained on the training data.
"""
periods = 10
steps_per_period = steps / periods
# Create a linear regressor object.
my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
linear_regressor = tf.estimator.LinearRegressor(feature_columns=feature_column(training_examples), optimizer=my_optimizer)
# 1. Create input functions.
training_input_fn = lambda: my_input_fn(training_examples, training_targets['median_house_value'], batch_size=1, shuffle=True, epochs=None)
predict_training_input_fn = lambda: my_input_fn(training_examples, training_targets['median_house_value'], shuffle=False, epochs=1)
predict_validation_input_fn = lambda: my_input_fn(validation_examples, validation_targets['median_house_value'], shuffle=False, epochs=1)
# Train the model, but do so inside a loop so that we can periodically assess
# loss metrics.
print("Training model...")
print("RMSE (on training data):")
training_rmse = []
validation_rmse = []
for period in range (0, periods):
# Train the model, starting from the prior state.
linear_regressor.train(
input_fn=training_input_fn,
steps=steps_per_period,
)
# 2. Take a break and compute predictions.
training_predictions = linear_regressor.predict(predict_training_input_fn)
training_predictions = np.array([item['predictions'][0] for item in training_predictions])
validation_predictions = linear_regressor.predict(predict_validation_input_fn)
validation_predictions = np.array([item['predictions'][0] for item in validation_predictions])
# Compute training and validation loss.
training_root_mean_squared_error = math.sqrt(
metrics.mean_squared_error(training_predictions, training_targets))
validation_root_mean_squared_error = math.sqrt(
metrics.mean_squared_error(validation_predictions, validation_targets))
# Occasionally print the current loss.
print(" period %02d : %0.2f" % (period, training_root_mean_squared_error))
# Add the loss metrics from this period to our list.
training_rmse.append(training_root_mean_squared_error)
validation_rmse.append(validation_root_mean_squared_error)
print("Model training finished.")
# Output a graph of loss metrics over periods.
plt.ylabel("RMSE")
plt.xlabel("Periods")
plt.title("Root Mean Squared Error vs. Periods")
plt.tight_layout()
plt.plot(training_rmse, label="training")
plt.plot(validation_rmse, label="validation")
plt.legend()
return linear_regressor
# + id="O5kek8LCaUny" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 525} outputId="ac6d67eb-e477-458f-cbc4-817a40bb2b18"
linear_regressor = train_model(learning_rate=0.00003, steps=500, batch_size=5, training_examples=training_examples, training_targets=training_targets, validation_examples=validation_examples, validation_targets=validation_targets)
# + id="aKOcVpEhbHJw" colab_type="code" colab={"base_uri": "https://localhost:8080/", "height": 34} outputId="3fb72610-0f25-4959-9ffa-ac8f71ef0d90"
# testing on test data
california_test_dataframe = pd.read_csv('https://download.mlcc.google.com/mledu-datasets/california_housing_test.csv', sep=',')
test_examples = preprocess_features(california_test_dataframe)
test_targets = preprocess_targets(california_test_dataframe)
predict_test_fn = lambda: my_input_fn(test_examples, test_targets['median_house_value'], shuffle=False, epochs=1)
predict_test_data = linear_regressor.predict(predict_test_fn)
predict_test_data = np.array([item['predictions'][0] for item in predict_test_data])
root_mean_squared_error = math.sqrt(
metrics.mean_squared_error(predict_test_data, test_targets))
print("Final RMSE (on test data): %0.2f" % root_mean_squared_error)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3 (TensorFlow 2.6 Python 3.8 GPU Optimized)
# language: python
# name: python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:us-west-2:236514542706:image/tensorflow-2.6-gpu-py38-cu112-ubuntu20.04-v1
# ---
# # Deacargar el Dataset
# !nvidia-smi
# +
# #!pip install kaggle
# #!chmod 600 kaggle.json
# #!cp kaggle.json ~/.kaggle/kaggle.json
# +
# #!kaggle competitions download -c dogs-vs-cats
# -
# #!unzip -q dogs-vs-cats.zip
# !unzip -q train.zip
# !unzip -q test1.zip
# +
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import os, shutil, pathlib
import matplotlib.pyplot as plt
from tensorflow.keras.utils import image_dataset_from_directory
print (tf.__version__)
print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))
# -
if tf.test.gpu_device_name():
print('Default GPU Device:',tf.test.gpu_device_name())
else:
print("Please install GPU version of TF")
original_dir = pathlib.Path("../train")
new_base_dir = pathlib.Path("../cats_vs_dogs_small")
# +
def make_subset(subset_name, start_index, end_index):
for category in ("cat", "dog"):
dir = new_base_dir / subset_name / category
os.makedirs(dir)
fnames = [f"{category}.{i}.jpg" for i in range(start_index, end_index)]
for fname in fnames:
shutil.copyfile(src=original_dir / fname,
dst=dir / fname)
make_subset("train", start_index=0, end_index=1000)
make_subset("validation", start_index=1000, end_index=1500)
make_subset("test", start_index=1500, end_index=2500)
# -
# !ls ../train | wc -l
# !ls ../test1 | wc -l
# !ls ../cats_vs_dogs_small/train/cat | wc -l
# !ls ../cats_vs_dogs_small/train/dog | wc -l
# !ls ../cats_vs_dogs_small/validation/cat | wc -l
# !ls ../cats_vs_dogs_small/validation/dog | wc -l
# !ls ../cats_vs_dogs_small/test/cat | wc -l
# !ls ../cats_vs_dogs_small/test/dog | wc -l
# # Dataloader y pre processing
train_dataset = image_dataset_from_directory(
new_base_dir / "train",
image_size=(180, 180),
batch_size=32)
validation_dataset = image_dataset_from_directory(
new_base_dir / "validation",
image_size=(180, 180),
batch_size=32)
test_dataset = image_dataset_from_directory(
new_base_dir / "test",
image_size=(180, 180),
batch_size=32)
# ### Creando una capa de data augmentation
data_augmentation = keras.Sequential(
[
layers.RandomFlip("horizontal"),
layers.RandomRotation(0.1),
layers.RandomZoom(0.2),
]
)
# ### Algunas imágenes de muestra
plt.figure(figsize=(10, 10))
for images, _ in train_dataset.take(1):
for i in range(9):
augmented_images = data_augmentation(images)
ax = plt.subplot(3, 3, i + 1)
plt.imshow(augmented_images[0].numpy().astype("uint8"))
plt.axis("off")
# # Creando y compilando una ConvNet (con augmentation y Dropout)
# +
from tensorflow import keras
from tensorflow.keras import layers
inputs = keras.Input(shape=(180, 180, 3))
x = data_augmentation(inputs)
x = layers.Rescaling(1./255)(x)
x = layers.Conv2D(filters=32, kernel_size=3, activation="relu")(x)
x = layers.MaxPooling2D(pool_size=2)(x)
x = layers.Conv2D(filters=64, kernel_size=3, activation="relu")(x)
x = layers.MaxPooling2D(pool_size=2)(x)
x = layers.Conv2D(filters=128, kernel_size=3, activation="relu")(x)
x = layers.MaxPooling2D(pool_size=2)(x)
x = layers.Conv2D(filters=256, kernel_size=3, activation="relu")(x)
x = layers.MaxPooling2D(pool_size=2)(x)
x = layers.Conv2D(filters=256, kernel_size=3, activation="relu")(x)
x = layers.Flatten()(x)
x = layers.Dropout(0.5)(x)
outputs = layers.Dense(1, activation="sigmoid")(x)
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(loss="binary_crossentropy",
optimizer="rmsprop",
metrics=["accuracy"])
model.summary()
# -
# # Ajustando el modelo 2.0
callbacks = [
keras.callbacks.ModelCheckpoint(
filepath="convnet_from_scratch_with_augmentation.keras",
save_best_only=True,
monitor="val_loss")
]
history = model.fit(
train_dataset,
epochs=100,
validation_data=validation_dataset,
callbacks=callbacks)
# # Loss y accuracy en training
import matplotlib.pyplot as plt
accuracy = history.history["accuracy"]
val_accuracy = history.history["val_accuracy"]
loss = history.history["loss"]
val_loss = history.history["val_loss"]
epochs = range(1, len(accuracy) + 1)
plt.plot(epochs, accuracy, "bo", label="Training accuracy")
plt.plot(epochs, val_accuracy, "b", label="Validation accuracy")
plt.title("Training and validation accuracy")
plt.legend()
plt.figure()
plt.plot(epochs, loss, "bo", label="Training loss")
plt.plot(epochs, val_loss, "b", label="Validation loss")
plt.title("Training and validation loss")
plt.legend()
plt.show()
# # Evauacion en el test
test_model = keras.models.load_model("convnet_from_scratch_with_augmentation.keras")
test_loss, test_acc = test_model.evaluate(test_dataset)
print(f"Test accuracy: {test_acc:.3f}")
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="35lxkB5RmKeh"
# This algorithm usually has a huge impact on understanding and on the conversational policies/states. As we are dealing with semantics also in other pipelines it is important to find the right steps and resources to complete it correctly and in here, we are preparing the field.
#
# To find the specific-domains semantics, a database is needed (can be also books related to the domains that are used for query purposes, or site’s corpuses, or any unstructured data related to the domain) together with the available corpuses that we have for the language model. It’s not important for corpuses to be large. In our research, 100-200 sentences for each type of conversation (chit-chat/ reactions/ restaurants advice/ legal consultancy etc.) are enough at this point.
#
# We don’t want to use pre-trained models that are coming with their own tokenizers and semantics from different domains.
#
# + id="ohoGr8BwmFG_"
# IN: input from pre-processing and Composed Words
# OUT: tuple (word/POS) + identified input for CVM
# + [markdown] id="LyR92TAYmZLC"
# Objectives:
#
# • Addressing words that are coming from the linguistic evaluation;
#
# • Retrieving information for CVM (verbs);
#
# • Addressing UNK words by finding their POS probabilities;
#
# • Addressing words that has more than one POS in lexicons/vocabularies and estimate their right POS;
#
# Language specificities: yes (first 2 objectives);
#
# Dependencies: Input Processing l/CVM/ Composed words;
#
# Database/ Vocabularies needed: Lexicon, verbs conjugations/forms, pronouns database, choose a database for POS training + Books database (that contains titles/first phrases for each chapter/sub-titles/ dialogues);
#
# + id="qR3OyPSzmiwv"
# To dos:
# 1. Retrieve information by evaluating each verb and send it to CVM (future/present/past, firsts person/second/third, affirmative/negative forms)
# 2. Bring words that are coming from linguistic evaluation to their common base/stem/lemma.
# 3. Train database for semantic (some nouns are marked in composed words for this task).
# 4. For every word make a tuple of the word and his POS.
# + [markdown] id="vBXpHP_Om9kx"
# Use existing codes
#
# Example codes (Do not use without adaptation):
#
# + id="1G2j2SKqnH-O"
# https://github.com/amanjeetsahu/Natural-Language-Processing-Specialization/blob/master/Natural%20Language%20Processing%20with%20Probabilistic%20Models/Week%203/C2_W3_Assignment_Solution.ipynb
# https://github.com/amanjeetsahu/Natural-Language-Processing-Specialization/blob/master/Natural%20Language%20Processing%20with%20Attention%20Models/Week%201/C4_W1_Assignment_Solution.ipynb
# https://github.com/amanjeetsahu/Natural-Language-Processing-Specialization/blob/master/Natural%20Language%20Processing%20with%20Classification%20and%20Vector%20Spaces/Week%202/C1_W2_Assignment_Solution.ipynb
# https://github.com/amanjeetsahu/Natural-Language-Processing-Specialization/blob/master/Natural%20Language%20Processing%20with%20Probabilistic%20Models/Week%203/C2_W3_Assignment_Solution.ipynb
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Importing libraries
import os, glob, csv, subprocess, sys, re, operator
from git import *
from subprocess import Popen, PIPE
from os import path
import pandas as pd
# # Configure repository and directories
# +
userhome = os.path.expanduser('~')
txt_file = open(userhome + r"/DifferentDiffAlgorithms/SZZ/code_document/project_identity.txt", "r")
pid = txt_file.read().split('\n')
project = pid[0]
bugidentifier = pid[1]
repository = userhome + r'/DifferentDiffAlgorithms/SZZ/datasource/' + project + '/'
analyze_dir = userhome + r'/DifferentDiffAlgorithms/SZZ/projects_analyses/' + project + '/'
print ("Project name = %s" % project)
print ("Project key = %s" % bugidentifier)
# -
# # Defining function to execute git command
def execute_command(cmd, work_dir):
#Executes a shell command in a subprocess, waiting until it has completed.
pipe = subprocess.Popen(cmd, shell=True, cwd=work_dir, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(out, error) = pipe.communicate()
return out, error
pipe.wait()
# # Loading the datasets
# Specifying column names
colnames = ['bug_id','bugfix_commitID','parent_id','filepath','filename_myers','filename_histogram','#deletions_myers','#deletions_histogram']
diffbugs = pd.read_csv(analyze_dir + '02_diff_extraction/03_file_having_deletedlines/buggyfiles_from_both_algorithms.csv')
diffbugs
# # Applying "git blame" for files
# Define pattern
pattern1 = re.compile(r'(?P<commit_id>[\^]\w+|\w+)\s+(?P [^\s]+)\s+\((?P<committer>.*?)\s+(?P<date>\d{4}-\d\d-\d\d)\s+(?P<time>\d\d:\d\d:\d\d).*?(?P<line_number>\b\d+\b)\)\s(?P<code>.*)')
pattern2 = re.compile(r'(?P<commit_id>[\^]\w+|\w+)\s+\((?P<committer>.*?)\s+(?P<date>\d{4}-\d\d-\d\d)\s+(?P<time>\d\d:\d\d:\d\d).*?(?P<line_number>\b\d+\b)\)\s(?P<code>.*)')
# Define header of table
header1 = ['bugintro_commitid', 'filename', 'committer', 'date', 'time', 'line_number', 'code']
header2 = ['bugintro_commitid', 'committer', 'date', 'time', 'line_number', 'code']
#Define directory
blame_dirs = analyze_dir + '03_annotate/01_annotated_files/'
# # Annotating files
# +
errorfile_hist = []
errorfile_myers = []
df_blame = []
for cc in range(0, len(diffbugs)):
sys.stdout.write("\rApplying git blame: %i" % (cc+1) + " / %i" % (len(diffbugs)))
sys.stdout.flush()
data = diffbugs.iloc[cc]
parent = data[2]
filepath = data[3]
bugid = data[0]
fixcid = data[1]
fn = ((data[3].split('/'))[-1:])[0]
fname = fn + "_" + data[1] + "-" + data[2][:10] + "_" + data[0]
blametxt = analyze_dir + '03_annotate/01_annotated_files/listof_diff_n_annotated_files/blame_' + fname + '_' + str(cc+1) + '.txt'
#checkout parentID and applying git blame
checkout = "git checkout -f " + parent
blame = "git blame " + filepath + " > " + blametxt
execute_command(checkout, repository)
execute_command(blame, repository)
b = open(blametxt, encoding="utf8", errors='ignore')
c = b.read().split('\n')
#annotating myers produced files
m_bugnum = data[6]
if m_bugnum != 0:
mmm = 'blamemyers_' + fname + '_' + str(cc+1) + '.csv'
name = analyze_dir + '03_annotate/01_annotated_files/blame_myers/csv/' + mmm
with open(name, 'w', newline='') as f:
writer = csv.writer(f)
try:
try:
pattern1.match(c[0]).groups()
writer.writerow(header1)
for line in c:
writer.writerow(pattern1.match(line).groups())
except:
pattern2.match(c[0]).groups()
writer.writerow(header2)
for line in c:
writer.writerow(pattern2.match(line).groups())
except:
if os.stat(blametxt).st_size == 0:
writer.writerow(header1)
tmp = [bugid, fixcid, parent, fn, filepath, fname + '_' + str(cc+1), m_bugnum]
errorfile_myers.append(tmp)
print (' : ' + fname + '_' + str(cc+1) + ' --> file not found')
pass
else:
mmm = "-"
#annotating histogram produced files
h_bugnum = data[7]
if h_bugnum != 0:
hhh = 'blamehistogram_' + fname + '_' + str(cc+1) + '.csv'
name = analyze_dir + '03_annotate/01_annotated_files/blame_histogram/csv/' + hhh
with open(name, 'w', newline='') as f:
writer = csv.writer(f)
try:
try:
pattern1.match(c[0]).groups()
writer.writerow(header1)
for line in c:
writer.writerow(pattern1.match(line).groups())
except:
pattern2.match(c[0]).groups()
writer.writerow(header2)
for line in c:
writer.writerow(pattern2.match(line).groups())
except:
if os.stat(blametxt).st_size == 0:
writer.writerow(header1)
tmp = [bugid, fixcid, parent, fn, filepath, fname + '_' + str(cc+1), h_bugnum]
errorfile_hist.append(tmp)
print (' : ' + fname + '_' + str(cc+1) + ' --> file not found')
pass
else:
hhh = "-"
tempo = [data[0],data[1],data[2],data[3],data[4],data[5],mmm,hhh,data[6],data[7]]
df_blame.append(tempo)
#exit from checkout
excheck = "git checkout -f origin"
execute_command(excheck, repository)
c = 1
for file in glob.iglob(analyze_dir + '03_annotate/01_annotated_files/listof_diff_n_annotated_files/*', recursive=True):
c += 1
try:
os.remove(file)
except FileNotFoundError:
print ("\nError: %s" % (file))
print ("\n'git blame' implementation is complete")
# -
#Save data_frame file into CSV file
with open(analyze_dir + '03_annotate/01_annotated_files/listof_diff_n_annotated_files/diff_n_blame_combination_files.csv',
'w') as dfcsv:
header = ['bug_id','bugfix_commitID','parent_id','filepath','diff_myers_file','diff_histogram_file',
'blame_myers_file','blame_histogram_file','#deletions_myers','#deletions_histogram']
writers = csv.writer(dfcsv)
writers.writerow(header)
for file in df_blame:
writers.writerow(file)
print ("The csv file has been created")
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # 1. Compound Data Types
# ## 1.1. list
# * A list is an object that contains multiple data items enclosed in square brakets.
# * Lists are mutable, which means that their contents can be changed during a program’s execution.
# * Lists are dynamic data structures, meaning that items may be added to them or removed from them.
# * Lists are _heterogenous_
["apples", "oranges", "cherries"]
prod_nums = ['V475', 'F987', 'Q143', 'R688']
sales_by_month = [250, 180, 360, 340]
# nested lists
sales_by_season = [[250, 180, 360], [340, 450, 250],[180, 230, 320], [550, 360, 190]]
# #### Exercise: Create a list to store your name, age and gender.
# +
# enter code here
# -
# ### 1.1.1. Common operations on lists
len(sales_by_month)
sales_by_month[1] = 230
sales_by_month
# ### List Sliceing / Indexing
sales_by_month[1:3]
# ### Creating Lists
# use list() and range() to create lists
a = list(range(2, 20))
a
a = list(range(2, 20, 2))
a
a[2:6] # note the stopping position is excluded
a[2:6:2]
# #### Exercise: Create a list of the first twenty positive integers, slice it to find all even numbers.
# +
# enter code here
# -
# ### 1.1.2 Other list operations
# ### Joining Lists
# joining two lists
sales_by_month = [250, 180, 360, 340]
sales_new = [99, 100, 101, 102]
sales_by_month += sales_new
sales_by_month
# use in function to find items in a list
prod_nums = ['V475', 'F987', 'Q143', 'R688']
search = input('Enter a product number: ')
if search in prod_nums:
print("We found the product")
else:
print("Product is not found")
# ### Iterating on a list
# for loop on a list
print('Month \t','Sales')
i=1
for x in sales_by_month:
print(i, '\t', x)
i=i+1
# ### 1.1.3. List Methods
# A method in python is similar to a function, except it is associated with an object. Unlike a function, methods are called on an object by `Object.method()`.
# 1. Use Tab key followed by `object.` to list all methods associated with the object.
# 2. Use `Object.method?` to show the key information about the method
#
# ### Useful methods for lists
A = list(range(1,6))
A
# .append() method to add elements to the end
A.append(30)
A
# .pop() removes the last element
A.pop()
A
A.pop(3) # remove the element at position 3
A
A.remove(2) # find the element 2 and remove it from the list
A
# .insert() adds an element to a specific position
A.insert(3, 20)
A
# .sort() to sort the elements in a list
A.sort()
A
# ### Copying Lists
A = list(range(1,6))
B = A
C = A.copy()
A[-1] = 20 # change the last element in A to 20
print(B) # the output will show that B has been changed too
print(C) # the list C remains the same
# ### Exercise:
# 1. Create a list containing the first twenty positive integers.
# 2. Create another list containing their squares
# +
# enter code here
# -
# ### Exercise - Find the median of a list of numbers
# 1. Median is the middle value in a **sorted** list of numbers.
# 2. Hint: Use `.sort()` and indexing
# +
# enter code here
# -
# ## 1.2. Tuples
# A tuple is a type of sequence that resembles a list, except that, unlike a list, a tuple is immutable (can't be changed). A tuple literal in Python is enclosed in parentheses.
warehouse = ('Chicago','Philadelphia','San Jose')
# ## 1.3. Dictionary
# Dictionaries are Python’s implementation of:
# 1. an associative array
# 2. a hash table
# 3. a lookup.
#
# A dictionary consists of a collection of key-value pairs (entries).
#
# A dictionary in Python is a comma-separated list of key-value pairs in curly braces {}. A colon (:) separates each key from its associated value:
# ```
# d = {<key>: <value>,<key>: <value>,..., <key>:<value>}
# ```
tel = {"Savannah":"476-3321", "Nathaniel":"351-7743"}
info = {'name': 'Molly', 'age': 25}
# ### 1.3.1. Common Dictionary Operations
# Accessing a value by a key
info['name']
# Adding a new key, value pair
info['job'] = "Analyst"
info
# Updating an existing key, value pair
info['name']='Sally'
info
# Removing a key, value pair
info.pop('name')
info
del info['name']
# Iterate through a dictionary
for key in info:
print(key,':', info[key])
# ### 1.3.2. Other Dictionary Operations
#
# * `len(d)`: Returns the number of entries in d.
# * `d.get(key [, default])`: Returns the value if the key exists or returns the default if the key does not exist. Raises an error if the default is omitted and the key does not exist.
# * `list(d.keys())`: Returns a list of the keys.
# * `list(d.values())`:Returns a list of the values.
# * `d.clear()`: Removes all entries from a dictionary.
# Length of the dict
len(info)
# List of keys in the dictionary
list(info.keys())
# List of values in the dictionary
list(info.values())
# Removing the contents of a dict
info.clear()
info
# ### 1.3.3 Dictionaries for representing data
import pandas as pd
data = {
"name": ["BYJU's", "Flipkart", "Shuttl"],
"industry": ["e-tech", "e-commerce", "transport"],
"funding (USD)": [200_000_000, 2_500_000_000, 8_048_394]
}
pd.DataFrame(data)
# +
# alternative
data = [{'name': "BYJU's", 'industry': 'e-tech', 'funding (USD)': 200000000},
{'name': 'Flipkart', 'industry': 'e-commerce', 'funding (USD)': 2500000000},
{'name': 'Shuttl', 'industry': 'transport', 'funding (USD)': 8048394}]
pd.DataFrame.from_records(data)
# -
# # Exercise:
# 1. Add a column to this dataset denoting the location (E.g:, Mumbai, Bangalore, Chennai)
# 2. Add a row to this dataset for PayTM - which is in the e-payments industry, located in Delhi and has received (suppose) a funding of 42 million USD.
# +
# enter code here
# -
# ## Quiz: Your CMS contains details of customers: name, age, sex and income.
#
# ### Q1.1: You want to find the average income. Which of the following would you use to store the income values?
#
# ### Q1.2: You want to add a new customer to the DB. Which of the following would you use to add the new record?
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python [default]
# language: python
# name: python3
# ---
# # 03. Deploying Jupyter
# ## Overview
# In this notebook, you will learn how to:
#
# - Configure remote Jupyter deployment.
# - Deploy Jupyter on a compute node.
# - Access deployed Jupyter Notebook.
# ## Import idact
# It's recommended that *idact* is installed with *pip*. Alternatively, make sure the dependencies are installed: `pip install -r requirements.txt`, and add *idact* to path, for example:
import sys
sys.path.append('../')
# We will use a wildcard import for convenience:
from idact import *
import bitmath
# ## Load the cluster
# Let's load the environment and the cluster. Make sure to use your cluster name.
load_environment()
cluster = show_cluster("hpc")
cluster
access_node = cluster.get_access_node()
access_node.connect()
# ## Configure remote Jupyter deployment
# ### Install Jupyter on the cluster
# Make sure Jupyter is installed with the Python 3.5+ distribution you intend to use on the cluster. The recommended version is JupyterLab.
# See [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html), [Jupyter Notebook](https://jupyter.readthedocs.io/en/latest/install.html).
#
# If you encounter any problems with deployment, this may be due to some library versions being incompatible. You can try installing frozen versions included with the *idact* repo in `envs/dask_jupyter_tornado.txt`:
#
# ```
# pip install -r dask_jupyter_tornado.txt
# ```
#
# You may need to add `--user`, if you are using a system Python distribution.
# ### Specify setup actions
# It's rare that the default Python distribution is the one you want to use for computation.
#
# Depending on your setup, you probably need to modify the `PATH` and `PYTHONPATH` environment variables, `source activate` a Conda environment, or perform other specific steps.
#
# In order for *idact* to find and execute the proper binaries, you'll need to specify these steps as a list of Bash script lines. Make sure to modify the list below to fit your needs.
cluster.config.setup_actions.jupyter = ['module load plgrid/tools/python-intel/3.6.2']
save_environment()
# ### Choose JupyterLab or Jupyter Notebook
# By default, JupyterLab is used. If you want to use regular Jupyter Notebook, set the config entry below to False.
cluster.config.use_jupyter_lab = True
save_environment()
# ## Allocate node for Jupyter
# We will deploy Jupyter on a single node. Make sure to adjust the `--account` parameter, same as in the previous notebook.
nodes = cluster.allocate_nodes(nodes=1,
cores=2,
memory_per_node=bitmath.GiB(10),
walltime=Walltime(minutes=10),
native_args={
'--account': 'intdata'
})
nodes
nodes.wait()
nodes
# Let's test the connection, just in case:
nodes[0].run('hostname')
# ## Deploy Jupyter
# After the initial setup, Jupyter can be deployed with a single command:
nb = nodes[0].deploy_notebook()
nb
# If the deployment succeeded, you can open the deployed notebook in the browser:
nb.open_in_browser()
# Confirm that there are no issues with the deployed Jupyter Notebook instance. Try to start a kernel and see if it looks stable. Make sure the version of Python you expected is used.
# If the Jupyter deployment failed for some reason, you will find the `jupyter` command log in the debug log file: `idact.log`.
#
# If your last failure is a timeout, e.g. `2018-11-12 22:14:00 INFO: Retried and failed: config.retries(...)`, check out the tutorial `07. Adjusting timeouts` if you believe the timeout might be too restrictive for your cluster.
# After you're done, you can cancel the deployment by calling `cancel`, though it will be killed anyway when the node allocation ends.
nb.cancel()
# Alternatively, the following will just close the tunnel, without attempting to kill Jupyter:
nb.cancel_local()
# ## Cancel the allocation
# It's important to cancel an allocation if you're done with it early, in order to minimize the CPU time you are charged for.
nodes.running()
nodes.cancel()
nodes.running()
# ## Next notebook
# In the next notebook, we will deploy a Dask.distributed scheduler and workers on several compute nodes, and browse their dashboards.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# +
# default_exp datasets.gowalla
# -
# # Gowalla dataset
# > Gowalla dataset.
#hide
from nbdev.showdoc import *
# +
#export
import os
import os.path as osp
import numpy as np
import pandas as pd
from pandas import Timedelta
from recohut.datasets.bases.session import SessionDatasetv3
from recohut.utils.common_utils import download_url, extract_gz
# -
#export
class GowallaDataset(SessionDatasetv3):
url = 'https://snap.stanford.edu/data/loc-gowalla_totalCheckins.txt.gz'
def __init__(self, root, interval=Timedelta(days=1), n=30000):
use_cols = [0, 1, 4]
super().__init__(root, use_cols, interval, n)
@property
def raw_file_names(self) -> str:
return 'loc-gowalla_totalCheckins.txt'
def download(self):
path = download_url(self.url, self.raw_dir)
extract_gz(path, self.raw_dir)
os.unlink(path)
ds = GowallaDataset(root='/content/gowalladata')
# !tree --du -h -C /content/gowalladata
#hide
# %reload_ext watermark
# %watermark -a "Sparsh A." -m -iv -u -t -d -p recohut
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# IMPORTS
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# %matplotlib inline
# -
apps = pd.read_csv('googleplaystore.csv')
apps.head()
apps.info()
# So, our dataset consists of 13 features describing each app on the dataset. Some features such as `Rating` have a lot of missing values. All the features are strings but that's not right for all the columns while some of them describing numerical values.
# Let's take a look at each column and try to find interesting results
# ### APP
len(apps['App'].unique())
# Out of the 10841 entries, only the 9660 are unique apps, we have to examine this further because if we continue as it is we will be working with duplicates in our dataset and our findings won't be so reliable.
apps.groupby('App').count()[apps.groupby('App').count()['Category'] != 1]['Category'].tail()
apps[apps['App'] == 'theScore: Live Sports Scores, News, Stats & Videos']
# Ok, we found all the double apps and as it seems they are exact copies of the same app, we have definitely to drop the double entries. With this method, we came up with a dataset cleaner already and smaller
apps_clean = apps.drop_duplicates(subset='App')
apps_clean.shape
# ### CATEGORY
#
#
(apps_clean['Category'].unique())
# Here we see that one category seems to have an uncommon name "1.9" we have to investigate that further, other than that we have nice and organized categories
apps_clean[apps_clean['Category'] == "1.9"]
# Ok only one APP within this category, we can easily delete this entry
apps_clean = apps_clean.drop(index=10472)
assert len(apps_clean[apps_clean['Category'] == "1.9"]) == 0
# ### RATING
# This feature is numerical, we take a look and see if we have any anomalies. We wait for all the values to be between 0 - 5 stars, this is the norm of rating an app in google play store.
apps_clean.describe()
# We have a min of 1 and a max of 5, nothing strange here, we will make a further analysis later in this notebook. Now let's check how many apps have no rating.
apps_clean.Rating.isnull().sum()
# 1463 apps have no rating at all, that's a little bit strange. After we have all the data in the final format we can investigate that further
# ### Reviews
# This feature is in text format but it represents numerical values
apps_clean.Reviews = pd.to_numeric(apps_clean.Reviews)
apps_clean.Reviews.describe()
# The values are parsed in numeric format and as we can see the min and max values are way out of the same range
# ### Size
# The size of the app is a numeric value too but is parsed as a string. We can turn them into numbers but we have another problem here, some of the apps are into Megabytes and some are into Kilobytes, plus there are apps that have no size. We can leave it as it is or we can make a function that looks the last letter and if it is MB it stays so if it is KB we turn it into megabytes by dividing with 1024.
def size_converter(data):
if data[-1] == 'M':
return float(data[:-1])
elif data[-1] == 'k':
return float(data[:-1]) / 1024
else:
return 0
apps_clean['Size'] = apps_clean['Size'].apply(size_converter)
apps_clean['Size'].describe()
# We have done the hard work and now we see that this feature is in numeric format, the min value raises some questions while the size of 0 Mb is something to think about, we assume that the app is too small. The max is 100 Mb lets see which app is that. Other than that apps have a normal size distribution.
apps_clean[apps_clean['Size'] == 100 ].groupby('Category')['Size'].count().sort_values(ascending = False)
# Ok most of the apps are games something that is normal for games to have such a big size
# ### Installs
apps_clean['Installs'].unique()
# This time we have again numerical values as text but the meaning is kind of abstract. We don't have an exact number but we have a group of values which our app is in. We can either make groups or convert all entries in numbers.
#
# I decide to go on using this feature as categorical, but I will change some things, I will make a new category 100- and I will put in all the apps with less 100 installations
def installs(data):
x = data.split('+')[0]
try:
if int(x) <= 100:
return '100-'
else:
return data
except ValueError:
return data
apps_clean['Installs'] = apps_clean['Installs'].apply(installs)
# ### Type
apps_clean['Type'].unique()
apps_clean[apps_clean['Type'].isnull()]
apps_clean.drop(index=9148, inplace=True)
# ### Price
apps_clean['Price'].unique()
# The prices seem to be either 0 for free apps and a dollar value for the paid ones. we can make this values numeric
def price_converter(price):
try:
return float(price.split('$')[1])
except IndexError:
return float(price)
apps_clean['Price'] = apps_clean['Price'].apply(price_converter)
apps_clean['Price'].describe()
# Ok we have to see which app cost so much money
apps_clean[apps_clean['Price'] == 400.0]
# Ok, a simple search in app store shoes as that this app is something like a way to prove you have money to spend, interesting.
apps_clean[apps_clean['Price'] > 100].head()
# Another filter in the dataset we see more apps as the first one!!!
# ### Content Rating
apps_clean['Content Rating'].unique()
# Ok a simple feature, nothing to do here yet
# ### Genres
apps_clean['Genres'].nunique()
# 118 unique app genres, I want to make a comparison with Category to see what's different
apps_clean[['Category', 'Genres']][:15]
# Ok it seems that we have the same values here, the Genre column seems to have sometimes more than one entry to explain where the app belongs, but for the simplicity, we can drop the feature as we have already something similar to go with.
apps_clean.drop('Genres', axis=1, inplace=True)
# ### Last Updated
apps_clean['Last Updated'].describe()
# Ok here we have dates, we can easy to convert the text format as a date.
apps_clean['Last Updated'] = pd.to_datetime(apps_clean['Last Updated'])
apps_clean.info()
# Ok now the column is converted and we can work better with dates type format
# ### Current Ver
apps_clean['Current Ver'].nunique()
# We have 2817 unique versions for each app. This feature has actually of no importance for our analysis
# ### Android Ver
apps_clean['Android Ver'].unique()
# This feature describes the versions of the android needs our phone for this app to work without a problem. Like the previous feature, we don't need this information for our further analysis.
apps_clean.drop(['Current Ver', 'Android Ver'], axis=1, inplace=True)
# # PLOT
apps_clean.head()
# ### What is the rating distribution?
plt.rcParams["figure.figsize"] = (10, 5)
apps_clean['Rating'].plot(kind='hist');
plt.title('Rating Distribution')
plt.xlabel('Rating(in stars)')
# Our plot shows that more apps ratted around 4.2 - 4.3 stars and only a few of them (< 500 apps) have less than 3 stars
# ### How rating and category are related?
# +
sns.boxplot(y='Rating', x='Category',data=apps_clean)
plt.tight_layout()
plt.xticks(rotation='vertical')
plt.axhline(apps_clean.Rating.median(), color='red')
# -
# More of the apps have good ratings but what is interesting is the outliers which show apps only in some of the categories. This can explain a user behavior such as when a user downloads an app without reading the description or without knowing what this app is about only to be disappointed after installation and give a bad rate, while other users download the same app knowing what this app is about and give the app a better rare. In contrast, we see app categories having less or no outliers, that make the app more robust and maybe the name of the app is not misleading in comparison of what the apps do.
#
# Let's see some examples: How rating and category are related?
# For example, the `ART_AND_DESIGN` category has no outliers while the `TOOLS` category has more
# +
fig, axes = plt.subplots(nrows=1, ncols=2, sharex='col')
apps_clean[apps_clean['Category'] == 'ART_AND_DESIGN']['Rating'].plot(kind='hist', ax=axes[0])
apps_clean[apps_clean['Category'] == 'TOOLS']['Rating'].plot(kind='hist', ax=axes[1])
axes[0].title.set_text('ART_AND_DESIGN')
axes[1].title.set_text('TOOLS')
# -
apps_clean[apps_clean['Category'] == 'ART_AND_DESIGN']['App'][10:20]
apps_clean[apps_clean['Category'] == 'TOOLS']['App'][10:20]
# Ok, we see that first category has a more robust rating but it has fewer ratings in total, looking in the apps name in this category we see maybe better app names. The other category has more ratings in total but has a lot of outliers and looking into the app names we see more complex names.
# ### Which category has the fewer stars rating?
apps_clean.groupby('Category')['Rating'].mean().sort_values()
# Ok it seems that the `DATE` category is the Category that receives the worsts ratings, while the `EVENTS` category has better ratings
# ### Which app updated latest and which is the oldest?
apps_clean['Last Updated'].describe()
# Ok there is an app that has to be updated from 2010
apps_clean[apps_clean['Last Updated'] == '2010-05-21 00:00:00']
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Markdown demonstration
# *This is an unordered list of some games I like*
# - Skyrim
# - Undertale
# - League of Legends
# - Civ3
# *This is an ordered list where I list cool mammals in alphabetical order*
# 1. Armadillo
# 2. Groundhog
# 3. Meerkat
# 4. Opossum
#
# *this is a basic block level code to print hello world*
# <code>
# uwu = "Hewwo Worwd OwO"
# print(uwu)
# </code>
#
# *this is the* **hypotenuse equation:**
# $\sqrt{a^2+b^2}$
#
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # sci-analysis
# An easy to use and powerful python-based data exploration and analysis tool
# ## Current Version
# 2.2 --- Released January 5, 2019
# ### What is sci-analysis?
# sci-analysis is a python package for quickly performing exploratory data analysis (EDA). It aims to make performing EDA easier for newcomers and experienced data analysts alike by abstracting away the specific SciPy, NumPy, and Matplotlib commands. This is accomplished by using sci-analysis's ``analyze()`` function.
#
# The main features of sci-analysis are:
# * Fast EDA with the analyze() function.
# * Great looking graphs without writing several lines of matplotlib code.
# * Automatic use of the most appropriate hypothesis test for the supplied data.
# * Automatic handling of missing values.
#
# Currently, sci-analysis is capable of performing four common statistical analysis techniques:
# * Histograms and summary of numeric data
# * Histograms and frequency of categorical data
# * Bivariate and linear regression analysis
# * Location testing
# ### What's new in sci-analysis version 2.2?
# * Version 2.2 adds the ability to add data labels to scatter plots.
# * The default behavior of the histogram and statistics was changed from assuming a sample, to assuming a population.
# * Fixed a bug involving the Mann Whitney U test, where the minimum size was set incorrectly.
# * Verified compatibility with python 3.7.
# ### Getting started with sci-analysis
# sci-analysis requires python 2.7, 3.5, 3.6, or 3.7.
#
# If one of these four version of python is already installed then this section can be skipped.
#
# If you use MacOS or Linux, python should already be installed. You can check by opening a terminal window and typing ``which python`` on the command line. To verify what version of python you have installed, type ``python --version`` at the command line. If the version is 2.7.x, 3.5.x, 3.6.x, or 3.7.x where x is any number, sci-analysis should work properly.
#
# > Note: It is not recommended to use sci-analysis with the system installed python. This is because the version of python that comes with your OS will require root permission to manage, might be changed when upgrading the OS, and can break your OS if critical packages are accidentally removed. More info on why the system python should not be used can be found here: https://github.com/MacPython/wiki/wiki/Which-Python
#
# If you are on Windows, you might need to install python. You can check to see if python is installed by clicking the Start button, typing ``cmd`` in the run text box, then type ``python.exe`` on the command line. If you receive an error message, you need to install python.
#
# The easiest way to install python on any OS is by installing Anaconda or Mini-conda from this page:
#
# <https://www.continuum.io/downloads>
#
# If you are on MacOS and have GCC installed, python can be installed with homebrew using the command:
# ```
# brew install python
# ```
#
# If you are on Linux, python can be installed with pyenv using the instructions here:
# <https://github.com/pyenv/pyenv>
#
# If you are on Windows, you can download the python binary from the following page, but be warned that compiling the required packages will be required using this method:
#
# <https://www.python.org/downloads/windows/>
# ### Installing sci-analysis
# sci-analysis can be installed with pip by typing the following:
#
# ```
# pip install sci-analysis
# ```
# On Linux, you can install pip from your OS package manager. If you have Anaconda or Mini-conda, pip should already be installed. Otherwise, you can download pip from the following page:
#
# <https://pypi.python.org/pypi/pip>
#
# sci-analysis works best in conjunction with the excellent pandas and jupyter notebook python packages. If you don't have either of these packages installed, you can install them by typing the following:
#
# ```
# pip install pandas
# pip install jupyter
# ```
# ### Using sci-analysis
# From the python interpreter or in the first cell of a Jupyter notebook, type:
import warnings
warnings.filterwarnings("ignore")
import numpy as np
import scipy.stats as st
from sci_analysis import analyze
# This will tell python to import the sci-analysis function ``analyze()``.
#
# > Note: Alternatively, the function ``analyse()`` can be imported instead, as it is an alias for ``analyze()``. For the case of this documentation, ``analyze()`` will be used for consistency.
#
# If you are using sci-analysis in a Jupyter notebook, you need to use the following code instead to enable inline plots:
# %matplotlib inline
import numpy as np
import scipy.stats as st
from sci_analysis import analyze
# Now, sci-analysis should be ready to use. Try the following code:
np.random.seed(987654321)
data = st.norm.rvs(size=1000)
analyze(xdata=data)
# A histogram, box plot, summary stats, and test for normality of the data should appear above.
#
# > Note: numpy and scipy.stats were only imported for the purpose of the above example. sci-analysis uses numpy and scipy internally, so it isn't necessary to import them unless you want to explicitly use them.
#
# A histogram and statistics for categorical data can be performed with the following command:
pets = ['dog', 'cat', 'rat', 'cat', 'rabbit', 'dog', 'hamster', 'cat', 'rabbit', 'dog', 'dog']
analyze(pets)
# Let's examine the ``analyze()`` function in more detail. Here's the signature for the ``analyze()`` function:
from inspect import signature
print(analyze.__name__, signature(analyze))
print(analyze.__doc__)
# ``analyze()`` will detect the desired type of data analysis to perform based on whether the ``ydata`` argument is supplied, and whether the ``xdata`` argument is a two-dimensional array-like object.
#
# The ``xdata`` and ``ydata`` arguments can accept most python array-like objects, with the exception of strings. For example, ``xdata`` will accept a python list, tuple, numpy array, or a pandas Series object. Internally, iterable objects are converted to a Vector object, which is a pandas Series of type ``float64``.
#
# > Note: A one-dimensional list, tuple, numpy array, or pandas Series object will all be referred to as a vector throughout the documentation.
#
# If only the ``xdata`` argument is passed and it is a one-dimensional vector of numeric values, the analysis performed will be a histogram of the vector with basic statistics and Shapiro-Wilk normality test. This is useful for visualizing the distribution of the vector. If only the ``xdata`` argument is passed and it is a one-dimensional vector of categorical (string) values, the analysis performed will be a histogram of categories with rank, frequencies and percentages displayed.
#
# If ``xdata`` and ``ydata`` are supplied and are both equal length one-dimensional vectors of numeric data, an x/y scatter plot with line fit will be graphed and the correlation between the two vectors will be calculated. If there are non-numeric or missing values in either vector, they will be ignored. Only values that are numeric in each vector, at the same index will be included in the correlation. For example, the two following two vectors will yield:
#
example1 = [0.2, 0.25, 0.27, np.nan, 0.32, 0.38, 0.39, np.nan, 0.42, 0.43, 0.47, 0.51, 0.52, 0.56, 0.6]
example2 = [0.23, 0.27, 0.29, np.nan, 0.33, 0.35, 0.39, 0.42, np.nan, 0.46, 0.48, 0.49, np.nan, 0.5, 0.58]
analyze(example1, example2)
# If ``xdata`` is a sequence or dictionary of vectors, a location test and summary statistics for each vector will be performed. If each vector is normally distributed and they all have equal variance, a one-way ANOVA is performed. If the data is not normally distributed or the vectors do not have equal variance, a non-parametric Kruskal-Wallis test will be performed instead of a one-way ANOVA.
#
# > Note: Vectors should be independent from one another --- that is to say, there shouldn't be values in one vector that are derived from or some how related to a value in another vector. These dependencies can lead to weird and often unpredictable results.
#
# A proper use case for a location test would be if you had a table with measurement data for multiple groups, such as test scores per class, average height per country or measurements per trial run, where the classes, countries, and trials are the groups. In this case, each group should be represented by it's own vector, which are then all wrapped in a dictionary or sequence.
#
# If ``xdata`` is supplied as a dictionary, the keys are the names of the groups and the values are the array-like objects that represent the vectors. Alternatively, ``xdata`` can be a python sequence of the vectors and the ``groups`` argument a list of strings of the group names. The order of the group names should match the order of the vectors passed to ``xdata``.
#
# > Note: Passing the data for each group into ``xdata`` as a sequence or dictionary is often referred to as "unstacked" data. With unstacked data, the values for each group are in their own vector. Alternatively, if values are in one vector and group names in another vector of equal length, this format is referred to as "stacked" data. The ``analyze()`` function can handle either stacked or unstacked data depending on which is most convenient.
#
# For example:
np.random.seed(987654321)
group_a = st.norm.rvs(size=50)
group_b = st.norm.rvs(size=25)
group_c = st.norm.rvs(size=30)
group_d = st.norm.rvs(size=40)
analyze({"Group A": group_a, "Group B": group_b, "Group C": group_c, "Group D": group_d})
# In the example above, sci-analysis is telling us the four groups are normally distributed (by use of the Bartlett Test, Oneway ANOVA and the near straight line fit on the quantile plot), the groups have equal variance and the groups have matching means. The only significant difference between the four groups is the sample size we specified. Let's try another example, but this time change the variance of group B:
np.random.seed(987654321)
group_a = st.norm.rvs(0.0, 1, size=50)
group_b = st.norm.rvs(0.0, 3, size=25)
group_c = st.norm.rvs(0.1, 1, size=30)
group_d = st.norm.rvs(0.0, 1, size=40)
analyze({"Group A": group_a, "Group B": group_b, "Group C": group_c, "Group D": group_d})
# In the example above, group B has a standard deviation of 2.75 compared to the other groups that are approximately 1. The quantile plot on the right also shows group B has a much steeper slope compared to the other groups, implying a larger variance. Also, the Kruskal-Wallis test was used instead of the Oneway ANOVA because the pre-requisite of equal variance was not met.
#
# In another example, let's compare groups that have different distributions and different means:
np.random.seed(987654321)
group_a = st.norm.rvs(0.0, 1, size=50)
group_b = st.norm.rvs(0.0, 3, size=25)
group_c = st.weibull_max.rvs(1.2, size=30)
group_d = st.norm.rvs(0.0, 1, size=40)
analyze({"Group A": group_a, "Group B": group_b, "Group C": group_c, "Group D": group_d})
# The above example models group C as a Weibull distribution, while the other groups are normally distributed. You can see the difference in the distributions by the one-sided tail on the group C boxplot, and the curved shape of group C on the quantile plot. Group C also has significantly the lowest mean as indicated by the Tukey-Kramer circles and the Kruskal-Wallis test.
# ### Using sci-analysis with pandas
# Pandas is a python package that simplifies working with tabular or relational data. Because columns and rows of data in a pandas DataFrame are naturally array-like, using pandas with sci-analysis is the preferred way to use sci-analysis.
#
# Let's create a pandas DataFrame to use for analysis:
# + code_folding=[]
import pandas as pd
np.random.seed(987654321)
df = pd.DataFrame(
{
'ID' : np.random.randint(10000, 50000, size=60).astype(str),
'One' : st.norm.rvs(0.0, 1, size=60),
'Two' : st.norm.rvs(0.0, 3, size=60),
'Three' : st.weibull_max.rvs(1.2, size=60),
'Four' : st.norm.rvs(0.0, 1, size=60),
'Month' : ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] * 5,
'Condition' : ['Group A', 'Group B', 'Group C', 'Group D'] * 15
}
)
df
# -
# This creates a table (pandas DataFrame object) with 6 columns and an index which is the row id. The following command can be used to analyze the distribution of the column titled **One**:
analyze(
df['One'],
name='Column One',
title='Distribution from pandas'
)
# Anywhere you use a python list or numpy Array in sci-analysis, you can use a column or row of a pandas DataFrame (known in pandas terms as a Series). This is because a pandas Series has much of the same behavior as a numpy Array, causing sci-analysis to handle a pandas Series as if it were a numpy Array.
#
# By passing two array-like arguments to the ``analyze()`` function, the correlation can be determined between the two array-like arguments. The following command can be used to analyze the correlation between columns **One** and **Three**:
analyze(
df['One'],
df['Three'],
xname='Column One',
yname='Column Three',
title='Bivariate Analysis between Column One and Column Three'
)
# Since there isn't a correlation between columns **One** and **Three**, it might be useful to see where most of the data is concentrated. This can be done by adding the argument ``contours=True`` and turning off the best fit line with ``fit=False``. For example:
analyze(
df['One'],
df['Three'],
xname='Column One',
yname='Column Three',
contours=True,
fit=False,
title='Bivariate Analysis between Column One and Column Three'
)
# With a few point below -2.0, it might be useful to know which data point they are. This can be done by passing the **ID** column to the `labels` argument and then selecting which labels to highlight with the `highlight` argument:
analyze(
df['One'],
df['Three'],
labels=df['ID'],
highlight=df[df['Three'] < -2.0]['ID'],
fit=False,
xname='Column One',
yname='Column Three',
title='Bivariate Analysis between Column One and Column Three'
)
# To check whether an individual **Condition** correlates between Column **One** and Column **Three**, the same analysis can be done, but this time by passing the **Condition** column to the groups argument. For example:
analyze(
df['One'],
df['Three'],
xname='Column One',
yname='Column Three',
groups=df['Condition'],
title='Bivariate Analysis between Column One and Column Three'
)
# The borders of the graph have boxplots for all the data points on the x-axis and y-axis, regardless of which group they belong to. The borders can be removed by adding the argument ``boxplot_borders=False``.
#
# According to the Spearman Correlation, there is no significant correlation among the groups. Group B is the only group with a negative slope, but it can be difficult to see the data points for Group B with so many colors on the graph. The Group B data points can be highlighted by using the argument ``highlight=['Group B']``. In fact, any number of groups can be highlighted by passing a list of the group names using the ``highlight`` argument.
analyze(
df['One'],
df['Three'],
xname='Column One',
yname='Column Three',
groups=df['Condition'],
boxplot_borders=False,
highlight=['Group B'],
title='Bivariate Analysis between Column One and Column Three'
)
# Performing a location test on data in a pandas DataFrame requires some explanation. A location test can be performed with stacked or unstacked data. One method will be easier than the other depending on how the data to be analyzed is stored. In the example DataFrame used so far, to perform a location test between the groups in the **Condition** column, the stacked method will be easier to use.
#
# Let's start with an example. The following code will perform a location test using each of the four values in the **Condition** column:
analyze(
df['Two'],
groups=df['Condition'],
categories='Condition',
name='Column Two',
title='Oneway from pandas'
)
# From the graph, there are four groups: Group A, Group B, Group C and Group D in Column **Two**. The analysis shows that the variances are equal and there is no significant difference in the means. Noting the tests that are being performed, the Bartlett test is being used to check for equal variance because all four groups are normally distributed, and the Oneway ANOVA is being used to test if all means are equal because all four groups are normally distributed and the variances are equal. However, if not all the groups are normally distributed, the Levene Test will be used to check for equal variance instead of the Bartlett Test. Also, if the groups are not normally distributed or the variances are not equal, the Kruskal-Wallis test will be used instead of the Oneway ANOVA.
#
# If instead the four columns **One**, **Two**, **Three** and **Four** are to be analyzed, the easier way to perform the analysis is with the unstacked method. The following code will perform a location test of the four columns:
analyze(
[df['One'], df['Two'], df['Three'], df['Four']],
groups=['One', 'Two', 'Three', 'Four'],
categories='Columns',
title='Unstacked Oneway'
)
# To perform a location test using the unstacked method, the columns to be analyzed are passed in a list or tuple, and the groups argument needs to be a list or tuple of the group names. One thing to note is that the groups argument was used to explicitly define the group names. This will only work if the group names and order are known in advance. If they are unknown, a dictionary comprehension can be used instead of a list comprehension to to get the group names along with the data:
analyze(
{'One': df['One'], 'Two': df['Two'], 'Three': df['Three'], 'Four': df['Four']},
categories='Columns',
title='Unstacked Oneway Using a Dictionary'
)
# The output will be identical to the previous example. The analysis also shows that the variances are not equal, and the means are not matched. Also, because the data in column **Three** is not normally distributed, the Levene Test is used to test for equal variance instead of the Bartlett Test, and the Kruskal-Wallis Test is used instead of the Oneway ANOVA.
#
# With pandas, it's possible to perform advanced aggregation and filtering functions using the GroupBy object's ``apply()`` method. Since the sample sizes were small for each month in the above examples, it might be helpful to group the data by annual quarters instead. First, let's create a function that adds a column called **Quarter** to the DataFrame where the value is either Q1, Q2, Q3 or Q4 depending on the month.
def set_quarter(data):
month = data['Month']
if month.all() in ('Jan', 'Feb', 'Mar'):
quarter = 'Q1'
elif month.all() in ('Apr', 'May', 'Jun'):
quarter = 'Q2'
elif month.all() in ('Jul', 'Aug', 'Sep'):
quarter = 'Q3'
elif month.all() in ('Oct', 'Nov', 'Dec'):
quarter = 'Q4'
else:
quarter = 'Unknown'
data.loc[:, 'Quarter'] = quarter
return data
# This function will take a GroupBy object called *data*, where *data*'s DataFrame object was grouped by month, and set the variable *quarter* based off the month. Then, a new column called **Quarter** is added to *data* where the value of each row is equal to *quarter*. Finally, the resulting DataFrame object is returned.
#
# Using the new function is simple. The same techniques from previous examples are used, but this time, a new DataFrame object called *df2* is created by first grouping by the **Month** column then calling the ``apply()`` method which will run the ``set_quarter()`` function.
quarters = ('Q1', 'Q2', 'Q3', 'Q4')
df2 = df.groupby(df['Month']).apply(set_quarter)
data = {quarter: data['Two'] for quarter, data in df2.groupby(df2['Quarter'])}
analyze(
[data[quarter] for quarter in quarters],
groups=quarters,
categories='Quarters',
name='Column Two',
title='Oneway of Annual Quarters'
)
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] id="Ifm3JBsFR8LT"
# # K-means Clustering for Anomaly Detection
# + id="2f3xSlfzR8LT"
# %matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
# + id="jHhYzVydPBnf"
plt.rcParams["figure.figsize"] = (15,10)
# + [markdown] id="smmcSc4FR8LT"
# ## Introducing K-means
# + [markdown] id="OqWluG89R8LT"
# K-means clustering is a simple and useful unsupervised learning algorithm. The goal of K-means clustering is to group similar data points into a set number (K) of groups. The algorithms does this by identifying 'centroids', which are the centers of clusters, and then allocating data points to the nearest cluster.
# + [markdown] id="ek7cdug9Rz7b"
# Let's try a simple example. First we should generate some clustered data. You could imagine these clusters are different stages in the normal operation of a machine.
# + id="yqxG6wjoR8LT" colab={"base_uri": "https://localhost:8080/", "height": 594} outputId="b3efc8df-9c7f-4fb7-92de-09f8f626b772"
from sklearn.datasets import make_blobs
num_centers = 3
X_train, y_train_true = make_blobs(n_samples=300, centers=num_centers,
cluster_std=0.40, random_state=0)
#plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train_true, s=50, cmap='viridis');
plt.scatter(X_train[:, 0], X_train[:, 1], s=50);
# + id="qRTkMLLuLFl-" colab={"base_uri": "https://localhost:8080/"} outputId="453f036c-deaf-4959-e0f0-229bf19c62eb"
X_train.shape
# + id="NVuzVGLjK9fC" colab={"base_uri": "https://localhost:8080/"} outputId="f104ab23-d50e-4d08-9e7a-8beaab250f5d"
X_train[:10]
# + id="4xtrJnnbLMuF" colab={"base_uri": "https://localhost:8080/"} outputId="71a02687-236c-44ed-cdf0-6f3a75fb16cc"
y_train_true
# + id="s0J39Qa_LS1j"
# + [markdown] id="PRfEjUUBR8LU"
# In this example it's pretty easy to visual distinguish the clusters.
#
# Now lets use [SKLearn's KMeans](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html) algorithm to fit to the data. This does a lot of the work for us, but if you would like to learn more about the underlying process check out the [wikipedia page](https://en.wikipedia.org/wiki/K-means_clustering#Algorithms)
# + id="q4NIBZ6zR8LU" colab={"base_uri": "https://localhost:8080/"} outputId="f5d27555-a2bf-484d-a1c8-e69432c890df"
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=num_centers) #we select three clusters
kmeans.fit(X_train) #we fit the centroids to the data
# + id="iHXgeAhlMl-R"
y_kmeans = kmeans.predict(X_train) #we determine the closest centroid for each datapoint
# + colab={"base_uri": "https://localhost:8080/"} id="Vci-fTAhMVvi" outputId="9f299138-c1f6-4d43-8e59-3b06bfd8713c"
y_kmeans
# + [markdown] id="F_TQ8Oh8R8LU"
# Now let's visualize the results. Each datapoint is color-coded according to the centroid they correspond to, and the centroids themselves are shown as black circles.
# + id="2pOtyuvhR8LU" colab={"base_uri": "https://localhost:8080/", "height": 594} outputId="709ffc11-031a-49a4-ac07-f5eab84683c1"
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_kmeans, s=50, cmap='viridis')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='black', s=200, alpha=0.5);
# + [markdown] id="ToMhXzc0R8LU"
# Looks like K-means does a great job in this simple example! Now let's explore how we can use this for anomaly detection.
#
# Below are new cluster that weren't part of our training data. We will pretend all of these are anomalies for the sake of a simple example.
#
# One of these clusters is completely different from the data we've seen before and another is only slightly different. We can easily visually separate one of the clusters, but the other one overlaps slightly with one of our training clusters. Given the low dimensionality of the data, it's reasonable that some new data is impossible to distinguish from the training data.
# + colab={"base_uri": "https://localhost:8080/", "height": 594} id="ZcyVY_nDX_Tn" outputId="75d3bace-d841-45ba-8b5b-a151810d0288"
X_anomaly, y_anomaly_true = make_blobs(n_samples=300, centers=2,
cluster_std=0.40, random_state=1)
plt.scatter(X_train[:, 0], X_train[:, 1], s=50);
plt.scatter(X_anomaly[:,0], X_anomaly[:,1], s=50);
# + [markdown] id="kh8TjeroaH1D"
# First we will calculate the distances from each datapoint to it's closest cluster center and then we calculate the 99 percentile distance for each center that was observed in the training data. We use the 99 percentile distance here since our training data could have some outliers.
#
# These distances will act as a bounday, beyond which we will classify datapoints as anomalies. The percentile can be adjusted to be more or less sensitive depending on the application and the training data.
# + colab={"base_uri": "https://localhost:8080/"} id="2-SOS7eJaIO0" outputId="01c41ba4-c014-46a7-dddd-3dcab226b3f9"
percentile_treshold = 99
train_distances = kmeans.transform(X_train)
center_distances = {key: [] for key in range(num_centers)}
for i in range(len(y_kmeans)):
min_distance = train_distances[i][y_kmeans[i]]
center_distances[y_kmeans[i]].append(min_distance)
center_99percentile_distance = {key: np.percentile(center_distances[key], \
percentile_treshold) \
for key in center_distances.keys()}
print(center_99percentile_distance)
# + [markdown] id="zAXOnuPHl0b7"
# Now let's plot those normal/abnomal boundaries on our training data to see how well they encompass our training data. We will also plot in yellow the points in our training data that are being classified as abnormal.
# + colab={"base_uri": "https://localhost:8080/", "height": 594} id="yjpUYr3hibYV" outputId="34c5f5fc-ba01-4cee-b545-21911cce8a14"
fig, ax = plt.subplots()
colors = []
for i in range(len(X_train)):
min_distance = train_distances[i][y_kmeans[i]]
if (min_distance > center_99percentile_distance[y_kmeans[i]]):
colors.append(4)
else:
colors.append(y_kmeans[i])
ax.scatter(X_train[:, 0], X_train[:, 1], c=colors, s=50, cmap='viridis')
for i in range(len(centers)):
circle = plt.Circle((centers[i][0], centers[i][1]),center_99percentile_distance[i], color='black', alpha=0.1);
ax.add_artist(circle)
# + [markdown] id="s9AR6TAUr3OH"
# Now let's add in the abnormal test data to see how it's classified.
# + colab={"base_uri": "https://localhost:8080/", "height": 628} id="T0qYhgT0r3hU" outputId="d37c07c8-a185-4010-dd7f-6d0da6c918e9"
fig, ax = plt.subplots()
anomaly_distances = kmeans.transform(X_anomaly)
y_anomaly = kmeans.predict(X_anomaly)
#combine all the data
combined_distances = [*train_distances, *anomaly_distances]
combined_y = [*y_kmeans, *y_anomaly]
all_data = np.array([*X_train, *X_anomaly])
false_neg=0
false_pos=0
colors = []
for i in range(len(all_data)):
min_distance = combined_distances[i][combined_y[i]]
if (min_distance > center_99percentile_distance[combined_y[i]]):
colors.append(4)
if (i<300): #training data is the first 300 elements in the combined list
false_pos+=1
else:
colors.append(combined_y[i])
if (i>=300):
false_neg+=1
ax.scatter(all_data[:, 0], all_data[:, 1], c=colors, s=50, cmap='viridis')
for i in range(len(centers)):
circle = plt.Circle((centers[i][0], centers[i][1]),center_99percentile_distance[i], color='black', alpha=0.1);
ax.add_artist(circle)
print('Normal datapoints misclassified as abnormal: ', false_pos)
print('Abnormal datapoints misclassified as normal: ', false_neg)
# + [markdown] id="1doZei2fLl8M"
# Our simple model did a pretty good job!
#
# Now we have a way to classify abnormal data in a simple two dimension space. You can adjust the `percentile_treshold` variable to see how that impacts the number of false positives and false negatives.
#
# Now let's see how well this applies to data with more dimensions.
# + [markdown] id="dDj3A9aCR8LV"
# ##K-means on Digits
#
#
# + [markdown] id="pQE7b1CvOMt6"
# First we load in our dataset of **64** pixel images of numerical digits (think MNIST in 8x8 pixel images), **a much higher dimmension** than our 2-D problem we were dealing with earlier.
# + id="KOIiHvXTR8LV"
from sklearn.datasets import load_digits
digits = load_digits()
normal_data = []
abnormal_data = []
normal_label = []
abnormal_label = []
num_clusters = 8
#separate our data arbitrarily into normal (2-9) and abnormal (0-1)
for i in range(len(digits.target)):
if digits.target[i]<10-num_clusters:
abnormal_data.append(digits.data[i])
abnormal_label.append(digits.target[i])
else:
normal_data.append(digits.data[i])
normal_label.append(digits.target[i])
# + [markdown] id="jqQ1nb4qR8LV"
# Next we find our cluster centers
# + id="WSXpxPoXR8LV" colab={"base_uri": "https://localhost:8080/"} outputId="44d1b297-7005-4908-8e0b-0bcd986f22d2"
kmeans = KMeans(n_clusters=num_clusters, random_state=0)
clusters = kmeans.fit_predict(normal_data)
kmeans.cluster_centers_.shape
# + [markdown] id="ipRk2AV8R8LV"
# Next let's visualize the centers that K-means found for each cluster. We see that K-means is able to find clusters whose centers are recognizable digits. A bit blury, but still recognizable to the human eye!
# + id="COPbqtpFR8LV" colab={"base_uri": "https://localhost:8080/", "height": 194} outputId="17ce69c1-f6e8-4e60-a48e-2b545fcc1136"
fig, ax = plt.subplots(2, int(num_clusters/2), figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(num_clusters, 8, 8)
for axi, center in zip(ax.flat, centers):
axi.set(xticks=[], yticks=[])
axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)
# + [markdown] id="6quDw3T4R8LV"
# Now let's find the 99 percentile boundary for these clusters as we did in the previous example.
# + id="NVvtt7OUR8LV" colab={"base_uri": "https://localhost:8080/"} outputId="94fa2ae3-e548-484b-c32c-a8d4f91a43f6"
percentile_treshold =99
normal_y = kmeans.predict(normal_data)
normal_distances = kmeans.transform(normal_data)
center_distances = {key: [] for key in range(num_clusters)}
for i in range(len(normal_y)):
min_distance = normal_distances[i][normal_y[i]]
center_distances[normal_y[i]].append(min_distance)
center_99percentile_distance = {key: np.percentile(center_distances[key], \
percentile_treshold) \
for key in center_distances.keys()}
print(center_99percentile_distance)
# + [markdown] id="A2ltV4eyR8LV"
# Now lets get the distance to each centroid for our anomalous data and combine it with our normal data. Then we can classify everything as either normal or abnormal based on the distances we calculated previously.
# + id="Pj7x4NjjR8LV" colab={"base_uri": "https://localhost:8080/"} outputId="c0bb608d-02b1-41e4-c7ca-90b0f49debe3"
abnormal_y = kmeans.predict(abnormal_data)
abnormal_distances = kmeans.transform(abnormal_data)
#combine all the data
combined_distances = [*normal_distances, *abnormal_distances]
combined_y = [*normal_y, *abnormal_y]
normal_data_length = len(normal_data)
all_data = np.array([*normal_data, *abnormal_data])
false_neg=0
false_pos=0
for i in range(len(all_data)):
min_distance = combined_distances[i][combined_y[i]]
if (min_distance > center_99percentile_distance[combined_y[i]]):
if (i<normal_data_length): #training data is first
false_pos+=1
else:
if (i>=normal_data_length):
false_neg+=1
print('Normal datapoints misclassified as abnormal: ', false_pos)
print('Abnormal datapoints misclassified as normal: ', false_neg)
# + [markdown] id="STL0sK-GR8LV"
# The results are ok but not ideal. We can try adjusting the `percentile_treshold` variable to get better results. However, generally, K-means doesn't scale well with increased dimensionality. This example is still very low dimensional compared to many real world use cases and it still has a significant impact on our accuracy. This relationship is called the [***Curse of Dimensionality***](https://en.wikipedia.org/wiki/Curse_of_dimensionality) which plauges many conventional machine learning algorithms.
#
# Next we will explore how to improve our K-means results with some pre-processing.
# + [markdown] id="g3IkAByRJ_G9"
# ##Dimensionality Reduction
#
# To combat the ***Curse of Dimensionality*** we can try projecting our data into a low dimensional space.
#
# We can use the t-distributed stochastic neighbor embedding ([t-SNE](https://en.wikipedia.org/wiki/T-distributed_stochastic_neighbor_embedding)) algorithm, to pre-process the data before feeding it into K-means. t-SNE is used to visualize high dimensional data and we can use it to reduce the dimensionality of our input data which will hopefully lead to better results!
#
# First we will run TSNE on all of our data (normal and abnormal) and later split it into our train (normal) and test (abnormal) data. This is becasue t-SNE is a transductive learner and is not intended to transform data beyond what it is trained on. There are some recent [implementations](https://github.com/kylemcdonald/Parametric-t-SNE) of a [parametric t-sne algorithm](https://lvdmaaten.github.io/publications/papers/AISTATS_2009.pdf) that can acomplish this but they are not included in sklearn.
# + id="997kxAbzR8LW" colab={"base_uri": "https://localhost:8080/"} outputId="16cec670-d30f-400f-ace7-1ac61a7889fa"
from sklearn.manifold import TSNE
# Project the data: this step will take several seconds
tsne = TSNE(n_components=2, init='random', random_state=0)
digits_proj = tsne.fit_transform(digits.data)
print(digits_proj.shape)
# + colab={"base_uri": "https://localhost:8080/", "height": 611} id="1Fw6CB01LU02" outputId="79542767-4814-4eea-f83b-43867c49783a"
#Visualize our new data
fig, ax = plt.subplots()
ax.scatter(digits_proj[:, 0], digits_proj[:, 1],c=digits.target, s=50, cmap='viridis')
# + [markdown] id="tg0wHyv-RFfH"
# Now we have nicely separated two dimension data (down from our 64 pixel images)! This looks a lot more like the clusters in the first example
#
# Next, we separate the data into normal and abnormal just like the previous example.
# + id="OMovdjEIREZ5"
normal_data = []
abnormal_data = []
normal_label = []
abnormal_label = []
num_clusters = 8
#separate our data arbitrarily into normal (2-9) and abnormal (0-1)
for i in range(len(digits.target)):
if digits.target[i]<10-num_clusters:
abnormal_data.append(digits_proj[i])
abnormal_label.append(digits.target[i])
else:
normal_data.append(digits_proj[i])
normal_label.append(digits.target[i])
# + [markdown] id="cVDatE4yXmtB"
# Now run K-means and calculate our percentile threshold.
# + colab={"base_uri": "https://localhost:8080/"} id="cBS7yNCnK2kw" outputId="0a29ff24-9f3a-4d78-d49d-827804867b69"
# Compute the clusters
kmeans = KMeans(n_clusters=num_clusters, random_state=0)
clusters = kmeans.fit_predict(normal_data)
#calculate the percentile bounday
percentile_treshold =99
normal_y = kmeans.predict(normal_data)
normal_distances = kmeans.transform(normal_data)
center_distances = {key: [] for key in range(num_clusters)}
for i in range(len(normal_y)):
min_distance = normal_distances[i][normal_y[i]]
center_distances[normal_y[i]].append(min_distance)
center_99percentile_distance = {key: np.percentile(center_distances[key], \
percentile_treshold) \
for key in center_distances.keys()}
print(center_99percentile_distance)
# + [markdown] id="xQkSkEUrX0U1"
# Finally we calculate the distances of our abnormal data to our cluster centers. Then count the number of false negatives and false positives and plot all the data.
# + colab={"base_uri": "https://localhost:8080/", "height": 628} id="ISboi3-sTaiL" outputId="17beba1a-08d4-48ae-9d6d-8d0d19860292"
abnormal_y = kmeans.predict(abnormal_data)
abnormal_distances = kmeans.transform(abnormal_data)
#combine all the data
combined_distances = [*normal_distances, *abnormal_distances]
combined_y = [*normal_y, *abnormal_y]
normal_data_length = len(normal_data)
all_data = np.array([*normal_data, *abnormal_data])
false_neg=0
false_pos=0
colors = []
for i in range(len(all_data)):
min_distance = combined_distances[i][combined_y[i]]
if (min_distance > center_99percentile_distance[combined_y[i]]):
colors.append(10)
if (i<normal_data_length): #training data is first in combined set
false_pos+=1
else:
colors.append(combined_y[i])
if (i>=normal_data_length):
false_neg+=1
fig, ax = plt.subplots()
ax.scatter(all_data[:, 0], all_data[:, 1], c=colors, s=50, cmap='viridis')
centers = kmeans.cluster_centers_
for i in range(len(centers)):
circle = plt.Circle((centers[i][0], centers[i][1]),center_99percentile_distance[i], color='black', alpha=0.1);
ax.add_artist(circle)
print('Normal datapoints misclassified as abnormal: ', false_pos)
print('Abnormal datapoints misclassified as normal: ', false_neg)
# + [markdown] id="KdGuqSYiYKv_"
# **Great results!!** We've drastically reduced the number of abnormal points being misclassified as normal!
#
# Unfortunately, while dimensionality reduction can be a power tool, it's not always a viable option. Algorithms like t-SNE can take a long time to run and won't always produce useful results.
#
# In the next section you will learn about a neural network approach to anomaly detection which can achieve high accuracy on high dimensional data.
# + [markdown] id="WCYghaoq6gwF"
# ## Additional Readings
# If you would like to learn about using reconstruction with K-means for anomaly detection check out: http://amid.fish/anomaly-detection-with-k-means-clustering
# + id="aQdqhr_5P7eS"
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Orbits in space
#
# Now that we know how to describe orbits in the perifocal frame, we need will look at how to move from this frame of reference to a more-general location in space.
#
# This module will cover:
# - Geocentric equatorial frame
# - Orbital elements
# - Gibbs problem
# - Gauss problem/Lambert theorem
# - Topocentric frame
import numpy as np
# %matplotlib inline
from matplotlib import pyplot as plt
# ## Geocentric equatorial frame
#
# In the geocentric equatorial frame, the Earth lies at the center and spins,
# where the $X-Y$ plane aligns with the equatorial plane of the planet and
# the planet's axis of rotation points in the $Z$ direction of the frame.
#
# Note that this frame does not align with the plane of the ecliptic (the solar plane),
# since the Earth's axis is tilted 23.44°.
#
# :::{figure,myclass} fig-gef
# <img src="../images/geocentric_equatorial.png" alt="Depiction of geocentric equatorial frame" class="bg-white mb-1" width="300px">
#
# Diagram of geocentric equatorial frame.
# Original source by [Tfr000](https://en.wikipedia.org/wiki/File:Ra_and_dec_rectangular.png),
# shared under [CC BY-SA](https://creativecommons.org/licenses/by-sa/3.0/deed.en)
# :::
#
# The $X$ axis of the geocentric equatorial frame always points in the same direction,
# towards the vernal equinox. This direction is also referred to as the first point
# in Aries, or with ♈, since this pointed to the constellation Aries back
# when the Greeks came up with the idea. However, due to the precession of the Earth's tilt,
# the direction changes over time, and it now points towards Pisces. In the year 2600,
# the vernal equinox will point towards Aquarius.
#
# Due to this precession, for precise orbital determinations we need to specify the
# direction of $X$ via the appropriate 50-year **epoch**. We are currently in the
# 2000 epoch, but in 2025 we will pass into the 2050 epoch.
#
# For an object in space, we can specify its position in the geocentric equatorial
# frame via its distance from the center ($r$), the angle away from the $X$ direction
# in the equatorial plane is the right ascension ($\alpha$), and the angle above
# the plane is the declination ($\delta$).
# ## Orbital elements
#
# In the perifocal frame, we can specify an object in orbit using the eccentricity $e$,
# the specific angular momentum $h$, and the true anomaly $\theta$.
# To specify the orientation of this plane in the geocentric equatorial frame,
# we need three additional quantities.
#
# :::{figure,myclass} fig-orbital-elements
# <img src="../images/orbital_elements.*" alt="Diagram with classical orbital elements" class="bg-white mb-1" width="400px">
#
# Diagram showing the orbital elements.
# Note that this uses $\nu$ for true anomaly, while we usually use $\theta$ here.
# Source: [Lasunncty](https://commons.wikimedia.org/wiki/File:Orbit1.svg) at the English Wikipedia / [CC BY-SA](http://creativecommons.org/licenses/by-sa/3.0/)
# :::
#
# The additional three quantities needed are the:
# * right ascension $\Omega$, which is the angle between the reference direction $\vec{X}$, or ♈, and the direction of the line of the ascending node $\vec{N}$;
# * inclination $i$, the angle of the perifocal frame away from the reference plane; and
# * argument of periapse/perigee $\omega$, the angle between the line of ascending node and direction of periapse $\vec{e}$.
#
# The orbit is prograde if $i <$ 90°, and retrograde if $i >$ 90°.
#
# Now, we have the six **orbital elements** needed to uniquely specify an orbit in a two-body system: $h, e, \theta, \Omega, i, \omega$.
# ### Two-line element sets
#
# Two-line element (TLE) sets, or "elsets", are a standard format used
# to encode and distribute the oribital elements of an object in space,
# along with other important information. These were originally designed
# for a 72-column punchcard format, like what FORTRAN 77 used.
#
# Particular column ranges encode specific information and quantities.
# Here is an example for the [NOAA-6 satellite](https://en.wikipedia.org/wiki/NOAA-6).
#
# ```
# NOAA 6
# 1 11416U 84123 A 86 50.28438588 0.00000140 00000-0 67960-4 0 5293
# 2 11416 98.5105 69.3305 0012788 63.2828 296.9658 14.24899292346978
# ```
#
# Line 0 contains the satellite name (up to 24 characters).
# On line 1: by column range:
#
# | Column | Description |
# | -------| ----------- |
# | 01 | line number (1) |
# | 03-07 | satellite number designated by USSPACECOM (11416) |
# | 08 | classification (`U` means unclassified) |
# | 10-11 | international designator, launch year (`84` means 1984) |
# | 12-14 | international designator, launch number (`123` means 124th launch) |
# | 15-17 | international designator, piece (`A` means first object) |
# | 19-20 | Epoch year (`86` means 1986) |
# | 21-32 | Epoch, Julian day fraction (`50.28438588` converts to 050:06:49:30.94) |
# | 34-43 | ballistic coefficient, or 1st time derivative of mean motion (`0.00000140`) |
# | 45-52 | 2nd derivative of mean motion, usually blank (`00000-0` = 0.00000) |
# | 54-61 | BSTAR, or drag term (`67960-4` means `0.67960e-4`) |
# | 63 | ephemeris type (`0`) |
# | 65-69 | element number and checksum |
#
# On line 2:
#
# | Column | Description |
# | -------| ----------- |
# | 01 | line number (2) |
# | 03-07 | satellite number designated by USSPACECOM (11416) |
# | 09-16 | inclination in degrees (`98.5105` means 98.5105°) |
# | 18-25 | right ascension of the ascending node in degrees (`69.3305` means 69.3305°) |
# | 27-33 | eccentricity (`0012788` means 0.0012788) |
# | 35-42 | argument of perigee, in degrees (`63.2828` means 63.2828°) |
# | 44-51 | mean anomaly, in degrees (`296.9658` means 296.9658°) |
# | 53-63 | mean motion, orbits per day (`14.24899292`) |
# | 64-68 | revolution number at epoch, in orbits (`34697`) |
# | 69 | checksum |
# ### Calculating orbital elements from state vectors
#
# Given the state vectors $\vec{r}$ and $\vec{v}$, a typical problem is to
# calculate the six orbital elements.
#
# First, calculate the magnitudes of relevant vectors:
#
# $$
# r = | \vec{r} | \quad v = |\vec{v}| \quad v_r = \frac{\vec{r} \cdot \vec{v}}{r}
# $$
#
# Then, calculate each of the orbital elements:
#
# 1. Specific angular momentum:
#
# $$
# \vec{h} = \vec{r} \times \vec{v} \quad h = |\vec{h}|
# $$
#
# 2. Inclination:
#
# $$
# i = \cos^{-1} \left( \frac{h_z}{h} \right)
# $$
#
# 3. Right ascension of the ascending node:
#
# $$
# \begin{align}
# \vec{N} &= \vec{K} \times \vec{h} \\
# N &= \left| \vec{N} \right| \\
# \Omega &= \begin{cases}
# \cos^{-1} \left( \frac{N_x}{N} \right) \quad \text{if } N_Y \geq 0 \;, \\
# 360° - \cos^{-1} \left( \frac{N_x}{N} \right) \quad \text{if } N_Y < 0 \;, \\
# \end{cases}
# \end{align}
# $$
#
# 4. Eccentricity:
#
# $$
# \vec{e} = \frac{1}{\mu} \left[ \left( v^2 - \frac{\mu}{r} \right) \vec{r} - r v_r \vec{v} \right] \quad e = | \vec{e} |
# $$
#
# 5. Argument of perigee (i.e., argument of periapse):
#
# $$
# \omega = \begin{cases}
# \cos^{-1} \left( \frac{\vec{N} \cdot \vec{e}}{N e} \right) \quad \text{if } e_Z \geq 0 \;, \\
# 360° - \cos^{-1} \left( \frac{\vec{N} \cdot \vec{e}}{N e} \right) \quad \text{if } e_Z < 0 \;, \\
# \end{cases}
# $$
#
# 6. True anomaly:
#
# $$
# \theta = \begin{cases}
# \cos^{-1} \left( \frac{\vec{e} \cdot \vec{r}}{e r} \right) \quad \text{if } v_r \geq 0 \;, \\
# 360° - \cos^{-1} \left( \frac{\vec{e} \cdot \vec{r}}{e r} \right) \quad \text{if } v_r < 0 \;, \\
# \end{cases}
# $$
# ### Calculating state vectors from orbital elements
#
# The opposite from above is calculating the position and velocity state vectors
# from the six orbital elements. We can do this by using $h, e, \theta$ to determine
# $\vec{r}$ and $\vec{v}$ in the perifocal frame, and then rotating into the
# geocentric equatorial frame of reference ($\vec{R}$ and $\vec{V}$).
#
# We can find the overall transformation by combining three rotation matrices:
#
# 1. Yaw about the $Z$ axis:
#
# $$
# R_3 \left( \Omega \right) = \begin{bmatrix}
# \cos \Omega & \sin \Omega & 0 \\
# -\sin \Omega & \cos \Omega & 0 \\
# 0 & 0 & 1 \end{bmatrix}
# $$
#
# 2. Pitch about the $X_P^{\prime}$ axis:
#
# $$
# R_1 \left( i \right) = \begin{bmatrix}
# 1 & 0 & 0 \\
# 0 & \cos i & \sin i \\
# 0 & -\sin i & \cos i \end{bmatrix}
# $$
#
# 3. Roll about the $Z_P^{\prime}$ axis:
#
# $$
# R_3 \left( \omega \right) = \begin{bmatrix}
# \cos \omega & \sin \omega & 0 \\
# -\sin \omega & \cos \omega & 0 \\
# 0 & 0 & 1 \end{bmatrix}
# $$
#
# 4. Calculate the total transformation matrix:
#
# $$
# \left[ Q_{Xx} \right] = R_3 \left( \omega \right) R_1 (i) R_3 \left( \Omega \right) \;,
# $$
#
# which involves matrix multiplications.
#
# 5. Calculate the new position and velocity vectors in the geocentric equatorial frame:
#
# $$
# \begin{align}
# \vec{R} &= \left[ Q_{Xx} \right]^{\top} \vec{r} \\
# \vec{V} &= \left[ Q_{Xx} \right]^{\top} \vec{v} \;,
# \end{align}
# $$
#
# where $\vec{r}$ and $\vec{v}$ are the state vectors in the perifocal frame:
#
# $$
# \begin{align}
# \vec{r} &= \frac{h^2 / \mu}{1 + e \cos \theta} \begin{bmatrix} \cos \theta & \sin \theta & 0 \end{bmatrix} \\
# \vec{v} &= \frac{\mu}{h} \begin{bmatrix} -\sin \theta & e + \cos \theta & 0 \end{bmatrix}
# \end{align}
# $$
# ## Gibbs problem
#
# One possible situation is determining the orbit from three sightings / position vectors;
# this is the Gibbs problem.
#
# **The problem:** Given $\vec{R}_1, \vec{R}_2, \vec{R}_3$, find the six orbital elements
# $h, e, \theta, \omega, \Omega, i$.
#
# :::{figure,myclass} fig-gibbs
# <img src="../images/gibbs-problem.png" alt="Diagram showing Gibbs problem" class="bg-white mb-1" width="400px">
#
# Diagram showing Gibbs problem.
# :::
#
# Note that the three position vectors must lie in the same plane, otherwise a stable
# two-body orbit is not possible.
#
# The goal here is to calculate the velocity vector at location 1, and then with $\vec{R}_1$ and $\vec{V}_1$
# the orbital elements can be found using the steps given above:
#
# $$
# \vec{V}_1 = \sqrt{ \frac{\mu}{N D} } \left( \frac{\vec{D} \times \vec{R}_1}{r_1} + \vec{S} \right) \;,
# $$
#
# where the magnitudes of the position vectors are $r_1 = \left| \vec{R}_1 \right|$, $r_2 = \left| \vec{R}_2 \right|$,
# $r_3 = \left| \vec{R}_3 \right|$, and the other vectors are
#
# $$
# \begin{align}
# \vec{N} &= r_1 \left( \vec{R}_2 \times \vec{R}_3 \right) + r_2 \left( \vec{R}_3 \times \vec{R}_1 \right) + r_3 \left( \vec{R}_1 \times \vec{R}_2 \right) \\
# \vec{D} &= \vec{R}_2 \times \vec{R}_3 + \vec{R}_3 \times \vec{R}_1 + \vec{R}_1 \times \vec{R}_2 \\
# \vec{S} &= \vec{R}_1 (r_2 - r_3) + \vec{R}_2 (r_3 - r_1) + \vec{R}_3 (r_1 - r_2) \;,
# \end{align}
# $$
#
# and the magnitudes are $N = \left| \vec{N} \right|$ and $D = \left| \vec{D} \right|$.
#
# :::{warning}
# You need to check that $\vec{D} \neq 0$, $\vec{N} \neq 0$, and that $\vec{D} \cdot \vec{N} \geq 0$.
# :::
# ## Lambert's problem
#
# Another fundamental problem is **Lambert's problem**, which is finding the orbit that connects two points in space for a given transfer time.
#
# :::{figure,myclass} fig-lambert
# <img src="../images/lambert-problem.png" alt="Diagram showing Lambert problem" class="bg-white mb-1" width="400px">
#
# Diagram showing Lambert's problem of orbital transfer between two points.
# :::
#
# **Problem:** Given $\vec{R}_1$, $\vec{R}_2$, and $\Delta t$, find the six orbital elements.
#
# Solution steps:
#
# 1. Calculate the radial position magnitudes: $r_1 = \left| \vec{R}_1 \right|$ and $r_2 = \left| \vec{R}_2 \right|$.
#
# 2. Calculate the change in true anomaly, depending on if the orbit is prograde or retrograde (assume prograde to start):
#
# $$
# \begin{align}
# \text{if prograde } (i < 90°): \Delta \theta &=
# \begin{cases}
# \cos^{-1} \left( \frac{\vec{R}_1 \cdot \vec{R}_2}{r_1 r_2} \right) \quad \text{if } \left(\vec{R}_1 \times \vec{R}_2 \right)_Z \geq 0 \\
# 360° - \cos^{-1} \left( \frac{\vec{R}_1 \cdot \vec{R}_2}{r_1 r_2} \right) \quad \text{if } \left(\vec{R}_1 \times \vec{R}_2 \right)_Z < 0
# \end{cases} \\
# \text{if retrograde } (i > 90°): \Delta \theta &=
# \begin{cases}
# \cos^{-1} \left( \frac{\vec{R}_1 \cdot \vec{R}_2}{r_1 r_2} \right) \quad \text{if } \left(\vec{R}_1 \times \vec{R}_2 \right)_Z < 0 \\
# 360° - \cos^{-1} \left( \frac{\vec{R}_1 \cdot \vec{R}_2}{r_1 r_2} \right) \quad \text{if } \left(\vec{R}_1 \times \vec{R}_2 \right)_Z \geq 0
# \end{cases} \\
# \end{align}
# $$
#
# 3. Calculate the quantity $A$:
#
# $$
# A = \sin \Delta \theta \sqrt{ \frac{r_1 r_2}{1 - \cos \Delta \theta}}
# $$
#
# 4. Iteratively solve for the universal anomaly parameter $z$:
#
# $$
# \begin{align}
# y(z) &= r_1 + r_2 + A \frac{z S(z) - 1}{\sqrt{C(z)}} \\
# \sqrt{\mu} \, \Delta t &= \left[ \frac{y(z)}{C(z)}\right]^{3/2} S(z) + A \sqrt{y(z)}
# \end{align}
# $$
#
# A reasonable initial guess is $z=1$. Then, these equations can be used with an equation solver like `fzero`
# in Matlab or `scipy.optimize.root_scalar` in Python to solve for $z$. If $z < 0$, the orbit is hyperbolic,
# and if $z > 0$ the solution is elliptic.
#
# 5. Calculate the universal Lagrange coefficients using the value of $z$:
#
# $$
# \begin{align}
# f &= 1 - \frac{y(z)}{r_1} \\
# g &= A \sqrt{ \frac{y(z)}{\mu} } \\
# \dot{f} &= \frac{\sqrt{\mu}}{r_1 r_2} \sqrt{ \frac{y(z)}{C(z)}} \left[ z S(z) - 1 \right] \\
# \dot{g} &= 1 - \frac{y(z)}{r_2}
# \end{align}
# $$
#
# where $C(z)$ and $S(z)$ are the Stumpf functions.
#
# 6. Calculate the velocities at each position:
#
# $$
# \begin{align}
# \vec{V}_1 &= \frac{1}{g} \left( \vec{R}_2 - f \vec{R}_1 \right) \\
# \vec{V}_2 &= \frac{1}{g} \left( \dot{g} \vec{R}_2 - \vec{R}_1 \right) \\
# \end{align}
# $$
#
# 7. With either state vector combination (say, $\vec{R}_1$ and $\vec{V}_1$), you can now obtain the orbital elements.
#
# If you find that the orbit is actually retrograde ($i > 90°$), then repeat the process starting at step 2 using the appropriate equation.
# ## Topocentric frame
#
# The **topocentric frame** describes the location of an orbiting object from a viewing location on the Earth's surface, based on instantaneous geodetic latitude ($\phi$) and longitude ($\theta$).
# This will be an instantaneous relationship, since latitude and longitude are fixed but on the rotating surface of the Earth.
#
# **The problem:** find the range and elevation from a viewing point on the surface, given the instantaneous position vector of the orbiting object in the geocentric equatorial frame $\vec{R}_{X}$,
# the geodetic latitude $\phi$, and the geodetic longitude $\theta$.
#
# Subscript meanings:
#
# - capital $X$: vector in the geocentric equatorial frame
# - lowercase $x$: vector in the topocentric frame
#
# The solution is to find the relative position vector in the geocentric equatorial frame,
# then rotate that into the local topocentric frame:
#
# $$
# \begin{align}
# \vec{\rho}_X &= \vec{R}_X - \vec{R}_{\text{site}} \\
# \vec{\rho}_x &= [Q_{Xx}] \vec{\rho}_X \;,
# \end{align}
# $$
#
# where $\vec{R}_{\text{site}}$ is the position vector from the Earth's center
# (i.e., the origin of the geocentric equatorial frame):
#
# $$
# \vec{R}_{\text{site}} = \left[ \frac{\bar{R}_e}{\sqrt{1 - (2f - f^2) \sin^2 \phi}} + H \right] \cos \phi
# \left\{ \cos \theta \, \vec{I} + \sin \theta \, \vec{J} \right\} + \\
# \left[ \frac{\bar{R}_e (1 - f)^2}{\sqrt{1 - (2f - f^2) \sin^2 \phi}} + H \right] \sin \phi \, \vec{K} \;,
# $$
#
# where $\bar{R}_e$ = 6378 km is the average radius of the Earth,
# $H$ is the altitude/elevation of the observing site, and
# $f = 0.003353$ is the oblatedness of the Earth.
# Then, $[Q_{Xx}] = R_1 \left( \phi \right) \cdot R_3 \left( \theta \right)$
# is the rotation matrix:
#
# $$
# \begin{align}
# R_1 \left( \phi \right) &= \begin{bmatrix}
# 1 & 0 & 0 \\
# 0 & -\sin \phi & \cos \phi \\
# 0 & \cos \phi & \sin \phi \end{bmatrix} \\
# R_3 \left( \theta \right) &= \begin{bmatrix}
# -\sin \theta & \cos \theta & 0 \\
# \cos \theta & \sin \theta & 0 \\
# 0 & 0 & 1 \end{bmatrix} \;.
# \end{align}
# $$
#
# Then, we can find the range with $\left| \vec{\rho}_x \right|$ and elevation with
#
# $$
# a = \sin^{-1} \left( \hat{\rho}_z \right) \quad \hat{\rho} = \frac{\vec{\rho}_x}{\left| \vec{\rho}_x \right|} \;,
# $$
#
# where $\hat{\rho}_z$ is the $z$-component of the unit position vector $\hat{\rho}$.
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# ---
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "96816ed7-b08a-4ca3-abb9-f99880c3535d", "showTitle": false, "title": ""}
This is a simple
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "6482be4c-f067-47c9-b0ac-35c938b94601", "showTitle": false, "title": ""}
# File location and type
file_location = "/FileStore/tables/feature_matrix-2.csv"
file_type = "csv"
# CSV options
data=spark.read.csv(file_location,header=True,inferSchema=True)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "bd82bb99-1479-4d5c-be10-8c36df0f1d44", "showTitle": false, "title": ""}
data.printSchema()
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "b5f66379-6f7f-42ec-8e82-d0e0926a1721", "showTitle": false, "title": ""}
data.show(10)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "db9631f6-bb4a-42ca-8a3c-0d48af932331", "showTitle": false, "title": ""}
d=data.select('Latitude')
d.show(10)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "aeda73fe-2d72-4ed3-9842-35d7c61d5f42", "showTitle": false, "title": ""}
data.columns
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "c7b5f9b1-8103-4088-8da0-a8aff7e850a9", "showTitle": false, "title": ""}
from pyspark.ml.feature import VectorAssembler
vect=VectorAssembler(inputCols=['Longitude','Latitude','Distance','Distance_x','Distance_y','PCI','PCI_64','PCI_65','PCI_302'],outputCol="independent")
output=vect.transform(data)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "6bd05968-820a-4f6c-8d24-0ee4788756bc", "showTitle": false, "title": ""}
output.select('independent').show(5)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "095f7e58-9379-40b4-a6ff-ed0c494a3206", "showTitle": false, "title": ""}
output.show(5)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "d3639f11-d4ad-4481-81fb-dc7e62572b2d", "showTitle": false, "title": ""}
final_data=output.select('independent','Speed')
final_data.show(5)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "627c1062-8f8c-4b28-9d0b-aafe8500d283", "showTitle": false, "title": ""}
from pyspark.ml.regression import LinearRegression
train_data,test_data=final_data.randomSplit([0.75,0.25])
regressor=LinearRegression(featuresCol='independent',labelCol='Speed')
regressor=regressor.fit(train_data)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "0e48d4b9-ae29-4b20-aa74-62d46f1dad75", "showTitle": false, "title": ""}
regressor.intercept
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "34e6731e-98cb-45eb-a714-5b6035227864", "showTitle": false, "title": ""}
regressor.coefficients
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "feb54064-d941-42cd-9b26-b69e8e4e5746", "showTitle": false, "title": ""}
pred=regressor.evaluate(test_data)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "d7534556-bbe2-4cee-ab5d-5cff51470cb9", "showTitle": false, "title": ""}
pred.predictions.show(10)
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "548d4ed8-4a13-4712-8889-c1b7205e0902", "showTitle": false, "title": ""}
print("The mean absolute error is {}".format(pred.meanAbsoluteError))
# + application/vnd.databricks.v1+cell={"inputWidgets": {}, "nuid": "c2e59ea5-9a95-4370-941f-3f3eb6311923", "showTitle": false, "title": ""}
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## CIS 9
# ## Introduction to Machine Learning
#
#
# Reading
# <br>The Data Science Handbook, Chapter 5:
# - What is machine learning
# - Introducing Scikit-learn
# Machine learning (ML) is a field that works with algorithms that can "learn," or improve themselves, due to their experience with input data and not due to a programmer writing a better algorithm. As the algorithm proceses more and more input data, it modifies itself to be more correct when encountering new data.
# Machine learning can be divided into 3 main categories: supervised learning, unsupervised learning, and reinforcement learning. Even though there is a wide spectrum of machine learning algorithms, in general most algorithms can be classified in one of these three categories. The following discusses each type of learning, in order from simple to more complex.
#
# In __supervised learning__ there are:
# - a known set of input called _features_. The standard variable name for the features is X.
# - a known set of output called _labels_. The standard variable name for the labels is y.
#
# The goal of the algorithm is to learn the mapping function that maps the input to the output. So that when given new samples of X features, the machine can correctly predict the corresponding y labels.
#
# Examples of common supervised learning applications:
# - Given features of a car, a truck, a bus, the algorithm can determine that a new vehicle is a truck. This is known as a _classification_ problem.
# - Given features of popular and unpopular movies, the algorithm can predict that a new movie is likely to be popular. This is known as a _regression_ problem.
#
# In __unsupervised learning__ there are:
# - a set of features X
# - no corresponding labels y
#
# The goal of the algorithm is to find previously unknown patterns in X. These patterns often are meaningful clusters of similar samples of X, which can show the categories or attributes intrinsic to the data. So that when given new samples of X, the machine can correctly identify the data.
#
# An example of a common unsupervised learning application:
# <br>Given features (such as buying and browsing habits) of customers, the algorithm can group customers with similar tendencies together for marketing purpose. This is known as a _clustering_ problem.
#
# In __reinforcement learning__ there are:
# - an initial state as input
# - criticism or reward
#
# The algorithm is given an initial state but not given any training data or features X. The algorithm iteratively explores the solution space, and when it reaches a conclusion it receives either criticism or reward (a weighted score). Based on this score, the algorithm continues to improve, and the best solution is the one with the most reward.
#
# Examples of common reinforcement learning applications:
# - An algorithm playing a complicated game such as chess. The initial state is the starting state of the game and a set of rules. The algorithm explores the solution space, which is dependent on the other player's moves, and use the learned cricism or reward to try to win the game.
# - A robot that navigates terrains to perform a task. The initial state comes from the environment around the robot, which is changeable. The algorithm uses its learned cricism or reward to respond to the changing environment and perform the task
# 0. Given the ice cream sales and temperature problem that was discussed in module 2 (matplotlib) exercise, in which the algorithm can advise the ice cream truck owner how much ice cream to store in the truck for selling, based on the week's temperature. What type of learning algorithm would it be?
# +
# This is supervised learning
# -
# The main steps of machine learning are:
# - Gather and prepare the training data
# - Choose an algorithm
# - Train the algorithm
# - Test the algorithm with new data
# To illustrate these steps, we start with a simple supervised learning example. The algorithm will learn some basic differences between an apple and an orange, and then identify if a new fruit is an apple or an orange.
# 1a. Gather data
# <br>Write code to read the fruits.xlsx file into a DataFrame, then print the DataFrame to view the data.
import pandas as pd
fruitsDF = pd.read_excel("fruits.xlsx")
print(fruitsDF)
# 1b. Prepare data
# <br>The fruit _features_ are the weight (in grams) and the skin texture (a smooth texture is closer to 0.0, the rough texture is closer to 1.0).
# <br>The fruit _labels_ are the fruit names: apple or orange
# <br>Write code to separate the DataFrame into:
# - a DataFrame named _features_ that has the weight and texture
# - a Series named _labels_ that has the fruit names
# +
# Method 1
features = fruitsDF[["Weight", "Texture"]].copy()
labels = pd.Series(fruitsDF.Fruit)
print(features, "\n")
print(type(features), "\n")
print(labels, "\n")
print(type(labels), "\n")
# Second Method
features = fruitsDF.loc[:, ["Weight","Texture"]]
print(features)
print()
print(type(features))
print()
labels = pd.Series(fruitsDF["Fruit"])
print(labels)
print()
print(type(labels))
# -
# 2. Choose an algorithm
# <br>This is often the most difficult step: finding the correct algorithm to do the job.
# Scikit-learn has a diagram for some of the common algorithms: https://scikit-learn.org/stable/tutorial/machine_learning_map/ and the steps to determine which algorithm or _estimator_ to try.
#
# For this example, since the algorithm needs to decide or classify if a fruit is an apple or an orage, the algorithm is called a _classifier_.
# <br>The classifier we'll use is a decision tree. A decision tree is like the Scikit-learn diagram above. In a decision tree the path is continuously split according to each feature. The algorithm makes a decision when it reaches the end of a path.
from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier()
# 3. Train the classifier
# <br>In Scikit-learn, the classifier is trained with the _fit_ method. The input to the fit method, the features and labels, are called the _training data_.
classifier = classifier.fit(features, labels)
# 4. Test the classifier with new data
# <br>After training, the classifier is given test data with the _predict_ method, and we can observe the output of the algorithm
print(classifier.predict([[85, 0.29]]))
# The second example is a more substantial example of supervised learning, it introduces a few more classifiers and show some common steps that are used in ML.
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
#from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestClassifier
# 5a. Gather data
# +
# Scikit-learn has many sample datasets available. We will use the wine dataset is an example.
wine = load_wine()
# Let's take a look at the general format of the sample datasets.
print(type(wine))
print("keys:\n", wine.keys()) # components of dataset
print("data:\n", wine.data, type(wine.data), wine.data.shape) # features
print("target:\n", wine.target, type(wine.target), wine.target.shape) # labels
print("frame:\n", wine.frame, type(wine.frame))
print("feature_name:\n", wine.feature_names, type(wine.feature_names)) # feature description
print("target_name:\n", wine.target_names, type(wine.target_names), wine.target_names.shape) # label description
#print("description:\n", wine.DESCR)
# -
# 5b. Prepare data
# find X
X = pd.DataFrame(wine.data, columns=wine.feature_names)
X.head(4)
# find y
y = pd.Series(wine.target)
print(y)
# divide the X and y data into 2 parts: training data and testing data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
# 6. Choose a classifier
# We try a few common classifiers to see which one works best
classifiers = [
KNeighborsClassifier(3),
DecisionTreeClassifier(),
RandomForestClassifier(),
GaussianNB()
]
# 7. Train and then test the classifier
# +
# go through each classifier
for classifier in classifiers:
# train the classifier
classifier.fit(X_train, y_train)
# test the trained classifier
y_output = classifier.predict(X_test)
# compare the predicted output with the actual output
print(classifier)
print(f"score: {f1_score(y_test, y_output, average='weighted'):.3f}")
# the f1 score shows how close the classifier output is to the actual label.
# A score of 1.0 is a perfect match, a score of 0.0 is no match
# -
# Which classifier performs best for the wine dataset?
# +
#
# -
import numpy as np
A = np.arange(1,16)
print(A.max(), A.min(), np.percentile(A,25))
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] colab_type="text" id="y54K2IajJAEB"
# # 06 - Introduction to Neural Networks
# Prepared by Jan Christian Blaise Cruz
#
# DLSU Machine Learning Group
# + colab={} colab_type="code" id="DUjG6JvnTqRY"
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
from sklearn.model_selection import train_test_split
from sklearn.datasets import fetch_openml
np.random.seed(42)
# %matplotlib inline
# + [markdown] colab_type="text" id="X9inNeJD6BSf"
# # The MNIST Dataset
# + [markdown] colab_type="text" id="RblDZdT_BV9U"
# First, we fetch the original MNIST dataset. This will take a while to load.
# + colab={} colab_type="code" id="Fti7ca8hVDc4"
mnist = fetch_openml('mnist_784')
# + [markdown] colab_type="text" id="4wt1Z6YFBaJv"
# The dataset has 70k samples of handwritten numbers. Each number is an image that's 28x28 pixels. If you flatten the image into one vector, you get a vector of size 784.
# + colab={"base_uri": "https://localhost:8080/", "height": 54} colab_type="code" id="6ZZxR5RL7C2n" outputId="048e6e21-ad85-4c66-a0a2-fe12a4fadb82"
mnist.data.shape
# + [markdown] colab_type="text" id="FnEV6-urBo1W"
# We can reshape a data sample into its original shape.
# + colab={"base_uri": "https://localhost:8080/", "height": 54} colab_type="code" id="nMHQq_sd7I_U" outputId="00b3f24a-641a-4812-896b-1e9a9a16e2cd"
mnist.data[0].reshape(28, 28).shape
# + [markdown] colab_type="text" id="IsHN3VjABr6Y"
# Let's plot some samples.
# + colab={"base_uri": "https://localhost:8080/", "height": 247} colab_type="code" id="r98SIF-37K69" outputId="ca246644-fb7b-4d6b-87b0-9277ecc5929a"
fig, ax = plt.subplots(2, 5)
ax = ax.flatten()
for i in range(10):
ax[i].imshow(mnist.data[i].reshape(28, 28), cmap='gray')
# + [markdown] colab_type="text" id="SZZTXAV2Bub7"
# The correct labels for these numbers are the following.
# + colab={"base_uri": "https://localhost:8080/", "height": 54} colab_type="code" id="IpvCtzOw7MAX" outputId="a291d28c-9687-4a9c-f234-bcc249334048"
mnist.target[:10]
# + [markdown] colab_type="text" id="asihMx7gBxpj"
# As always, we first split into training and testing sets. We cast the data into floats to preserve memory, and the targets into integers since they're currently strings.
# + colab={"base_uri": "https://localhost:8080/", "height": 54} colab_type="code" id="pPB7dMPx7C_S" outputId="bc7d926e-9d31-4f59-d48e-0acec0e59b45"
# Split the dataset
X_train, X_test, y_train, y_test = train_test_split(mnist.data.astype(np.float32),
mnist.target.astype(np.int),
random_state=42)
X_train.shape, X_test.shape, y_train.shape, y_test.shape
# + [markdown] colab_type="text" id="Mqbv_78T6Dkm"
# # Minibatch Training
# + [markdown] colab_type="text" id="48JTkvD2B4zL"
# From this point, we will implement *Minibatch* stochastic gradient descent. Minibatching refers to dividing a training set into multiple small batches, then iterating over these batches every epoch. Since we apply gradient descent per batch, we essentially allow the model more room to "learn" by giving it multiple batches instead of feeding it the entire dataset at once.
#
# This function yields a random batch from given inputs and targets.
# + colab={} colab_type="code" id="FMaOsSfAvme9"
def batchify(inputs, targets, batch_size):
indices = np.random.permutation(len(inputs))
for start_idx in range(0, len(inputs) - batch_size + 1, batch_size):
batch = indices[start_idx:start_idx + batch_size]
yield inputs[batch], targets[batch]
# + [markdown] colab_type="text" id="OUmjGCVdCQQq"
# Let's create dataloaders for the training and testing sets so we can iterate over them.
# + colab={} colab_type="code" id="nGc6E3O0vmhS"
bs = 32
train_loader = [b for b in batchify(X_train, y_train, bs)]
test_loader = [b for b in batchify(X_test, y_test, bs)]
# + [markdown] colab_type="text" id="jh2NUBoXCULc"
# We can check the first batch in a loader.
# + colab={"base_uri": "https://localhost:8080/", "height": 54} colab_type="code" id="p5VlBhup0PMJ" outputId="b622d804-a270-43e5-eb22-a51cdef6a44e"
x, y = train_loader[0]
print(x.shape, y.shape)
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="GJp8GCwEgXAG" outputId="aec2ca24-fdd6-49b6-f252-6dc95dc76e85"
y
# + [markdown] colab_type="text" id="LlL76uJ66Ffy"
# # Basic Neural Networks
# + [markdown] colab_type="text" id="jGVKDn9WCbcB"
# Let's implement a class for a neural network layer.
#
# We include the weights and biases of the layer and give it functions for forward and backward propagation.
#
# Forward propagation is straightforward. We apply a matrix multiplication then return the pre activation. We do not include the activation function within the class so we can do with the pre activations as we please.
#
# Backward propagation, while a little more involved, is also quite simple. We compute for the weighted errors (new deltas), then get the gradients by applying a dot product with the activations of the previous layer.
#
# We then apply a gradient descent step and return the new delta errors so we can pass this to the previous layer in the chain while backpropagating.
# + colab={} colab_type="code" id="f8jIjZO8UkAX"
class Linear:
def __init__(self, input_dim, output_dim, learning_rate=3e-4):
self.learning_rate = learning_rate
self.weights = np.random.randn(input_dim, output_dim) * 0.01
self.biases = np.zeros(output_dim)
def forward(self, activations):
return np.matmul(activations, self.weights) + self.biases
def backward(self, grad_activations, delta):
# Compute weighted errors
new_delta = np.dot(delta, np.transpose(self.weights))
# Dot product with gradient of activations
grad_weights = np.transpose(np.dot(np.transpose(delta), grad_activations))
grad_biases = np.sum(delta, axis=0)
# Update weights
self.weights = self.weights - self.learning_rate * grad_weights
self.biases = self.biases - self.learning_rate * grad_biases
return new_delta
# + [markdown] colab_type="text" id="2P0vOHPYDkNL"
# We implement only one activation function, which is the rectified linear unit. The structure follows the structure of our linear layer.
# + colab={} colab_type="code" id="-zfvVYqCU2E3"
class ReLU:
def __init__(self):
pass
def forward(self, x):
return np.maximum(0, x)
def backward(self, grad_activations, delta):
relu_grad = grad_activations > 0
new_delta = delta * relu_grad
return new_delta
# + [markdown] colab_type="text" id="r0VqhLd2Duvf"
# We can test out getting the pre activations using our linear layer.
# + colab={"base_uri": "https://localhost:8080/", "height": 272} colab_type="code" id="nSr2uu3W0ijn" outputId="478b3b00-2d45-47bb-fc4c-dd7e54cdb356"
fc1 = Linear(784, 128)
relu = ReLU()
z = fc1.forward(x)
print(z.shape)
print(z)
# + [markdown] colab_type="text" id="BrOyr92gDyV8"
# And as expected, applying a relu will bound our pre activations between 0 and infinity.
# + colab={"base_uri": "https://localhost:8080/", "height": 272} colab_type="code" id="moI3JcjA0il3" outputId="853905e4-cc9b-4304-be19-b799d135ade3"
a = relu.forward(z)
print(a.shape)
print(a)
# + [markdown] colab_type="text" id="EoYdblsK6IcK"
# # Softmax Cross Entropy
# + [markdown] colab_type="text" id="P19PLjXMD3F0"
# As for softmax, we do not implement it as a layer, but instead we incorporate it into our loss function. It is convention that we leave the final pre activations untouched so that we can use them should we need to (for example, chaining to another neural network or layer).
#
# Anyhow, we implement a cross entropy loss function like this. Since we're handling multiple labels, we take the predicted logits for each correct label, then compute for the entropy. We introduce an epsilon value to prevent the logarithm from encountering a zero.
#
#
# + colab={} colab_type="code" id="MXQv2u7TU7Dk"
def cross_entropy_loss(logits, y):
# Get activations for correct answers (softmax), then compute cross-entropy
logits_for_labels = logits[np.arange(len(logits)), y]
entropy = -logits_for_labels + np.log(np.sum(np.exp(logits) + 1e-18, axis=-1))
return np.mean(entropy)
# + [markdown] colab_type="text" id="NDRCRVP-Ee7W"
# Likewise, we need to implement a version of the loss function for backpropagation.
#
# We subtract the softmaxed logits with the correct answers (which are expanded into a one-hot vector). This is our initial delta error.
# + colab={} colab_type="code" id="ma0Kr7s06MeV"
def grad_cross_entropy_loss(logits, y):
# One-hot encode the correct answers
one_hot = np.zeros_like(logits)
one_hot[np.arange(len(logits)), y] = 1
# Get the softmax
softmax = np.exp(logits) / np.exp(logits).sum(axis=-1, keepdims=True)
# Initial delta is the output - correct answer. Divide to get the mean.
delta = (softmax - one_hot) / logits.shape[0]
return delta
# + [markdown] colab_type="text" id="TOTe-1VK6NHD"
# # Foward and Backpropagation
# + [markdown] colab_type="text" id="EPHw1_2nEuQt"
# Let's write convenience functions for forward and back propagation.
#
# Forward propagation is simple. We apply the forward function for all layers in our network, which is a list of layers.
# + colab={} colab_type="code" id="qFPUeCVUVNfd"
def forwardprop(network, x):
activations = []
# Pass through first layer
out = network[0].forward(x)
activations.append(out)
# Forward prop through all layers 1 to L
for i in range(1, len(network)):
out = network[i].forward(out)
activations.append(out)
return activations
# + [markdown] colab_type="text" id="6tpwj1RBE2dI"
# For backprop, we iterate from the last layer. Each layer and the activations of the previous layer are used.
# + colab={} colab_type="code" id="gJlSyz_K1lC4"
def backprop(network, logits, y):
# Calculate the loss and initial delta
loss = cross_entropy_loss(logits, y)
delta = grad_cross_entropy_loss(logits, y)
# Propagate delta backwards
for i in range(1, len(network))[::-1]:
delta = network[i].backward(activations[i - 1], delta)
return loss
# + [markdown] colab_type="text" id="UNf43Ek2E7hD"
# We also implement an accuracy function for convenience.
# + colab={} colab_type="code" id="x7jc2DIz19eP"
def accuracy(logits, y):
return np.sum(np.argmax(logits, 1) == y) / len(y)
# + [markdown] colab_type="text" id="hgdNdugjE-SR"
# Let's instantiate a simple one hidden layer network.
# + colab={} colab_type="code" id="EwnJ8yc2VhBE"
network = [
Linear(784, 128),
ReLU(),
Linear(128, 10),
]
# + [markdown] colab_type="text" id="zKJGsrCxFCKg"
# Then sample a batch from the dataset.
# + colab={} colab_type="code" id="Bc_JSFxX2i0u"
x, y = train_loader[0]
# + [markdown] colab_type="text" id="K2QxaljMFEoR"
# This gives us one run of forward and back propagation (with one step of gradient descent)
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="r8ueduzHVhkR" outputId="d4156049-bba6-4465-f057-893f01881e0a"
# Forward Propagation
activations = forwardprop(network, x)
logits = activations[-1]
print("Shape of logits:", logits.shape)
# Backpropagation
loss = backprop(network, logits, y)
acc = accuracy(logits, y)
print("Loss {:.4f} | Accuracy {:.2f}%".format(loss, acc * 100))
# + [markdown] colab_type="text" id="WZTeJzNmFJWw"
# Another forward and backward pass shows us that our network is improving as the loss is going down.
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="KdF9cHdP7rUo" outputId="59c70247-db96-45db-ea2a-1c6cfcca5707"
# Forward Propagation
activations = forwardprop(network, x)
logits = activations[-1]
print("Shape of logits:", logits.shape)
# Backpropagation
loss = backprop(network, logits, y)
acc = accuracy(logits, y)
print("Loss {:.4f} | Accuracy {:.2f}%".format(loss, acc * 100))
# + [markdown] colab_type="text" id="TI4eZ5Xu6QB_"
# # Putting it all Together
# + [markdown] colab_type="text" id="N5zu7B-8FNbh"
# Let's reinstantiate our neural network and set a learning rate.
# + colab={} colab_type="code" id="xYEFcq_GgI-o"
network = [
Linear(784, 128, learning_rate=3e-5),
ReLU(),
Linear(128, 10, learning_rate=3e-5),
]
# + [markdown] colab_type="text" id="pWgercG7FQPv"
# We then train for 10 epochs. We iterate through each minibatch. For each minibatch, we perform forward and backward propagation, including one step of gradient descent to update our parameters. We log our loss and average per batch. We then take the average of the losses and accuracies.
# + colab={"base_uri": "https://localhost:8080/", "height": 699} colab_type="code" id="q5EQ-wcbnAPB" outputId="d9539c03-6c2b-48cb-b17c-9ee71927bba0"
epochs = 10
for e in range(1, epochs + 1):
# Training Loop
train_loss = 0
train_acc = 0
for batch in tqdm(train_loader):
x, y = batch
activations = forwardprop(network, x)
logits = activations[-1]
loss = backprop(network, logits, y)
acc = accuracy(logits, y)
train_loss += loss
train_acc += acc
train_loss /= len(train_loader)
train_acc /= len(train_loader)
# Testing Loop
test_loss = 0
test_acc = 0
for batch in tqdm(test_loader):
x, y = batch
activations = forwardprop(network, x)
logits = activations[-1]
loss = cross_entropy_loss(logits, y)
acc = accuracy(logits, y)
test_loss += loss
test_acc += acc
test_loss /= len(test_loader)
test_acc /= len(test_loader)
print("\nEpoch {:3d} | Train Loss {:.4f} | Test Loss {:.4f} | Train Acc {:.2f}% | Test Acc {:.2f}%".format(e, train_loss, test_loss, train_acc * 100, test_acc * 100))
# + [markdown] colab_type="text" id="OL-ea3wlFe9P"
# We can test some predictions after we train.
# + colab={} colab_type="code" id="oNy0KwzG48w2"
x, y = test_loader[0]
activations = forwardprop(network, x)
logits = activations[-1]
# + [markdown] colab_type="text" id="wEEC7wNPFgqp"
# Here are the predicted numbers.
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="Nhj4g5t45022" outputId="810e2220-891e-45ea-bccf-100b0121acf1"
np.argmax(logits, 1)
# + [markdown] colab_type="text" id="jrjjctJbFiQL"
# And here are the correct labels.
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="IhpfVK-v51SG" outputId="9c0277b1-1c18-4e74-e81a-691cd1fbd0ea"
y
# + [markdown] colab_type="text" id="4y7QRGnG9Ld2"
# # From Numpy to PyTorch
# + [markdown] colab_type="text" id="2tv06OUAFm2I"
# *Adapted from the PyTorch Tutorials*
#
# While Numpy works well as a linear algebra library, we are starting to see its limits. For one, it is tedious to create larger and more complicated neural networks because we have to take note of each and every activation per layer, then handle backpropagation likewise.
#
# Here's a simple one hidden layer neural network that fits random toy data. We train for 500 epochs using simple MSE loss.
# + colab={"base_uri": "https://localhost:8080/", "height": 203} colab_type="code" id="puDeiUWM54tl" outputId="a136a7d5-88a5-4f9f-dbca-9fd80ab41fa9"
np.random.seed(42)
bs, input_dim, hidden_dim, output_dim = 32, 100, 128, 10
# Create random input and output data
x = np.random.randn(bs, input_dim)
y = np.random.randn(bs, output_dim)
# Randomly initialize weights
theta_l1 = np.random.randn(input_dim, hidden_dim)
theta_l2 = np.random.randn(hidden_dim, output_dim)
learning_rate = 1e-6
epochs = 500
for e in range(1, epochs + 1):
# Forward propagation
z_l1 = x.dot(theta_l1)
a_l1 = np.maximum(z_l1, 0)
y_pred = a_l1.dot(theta_l2)
# Compute for loss
loss = np.square(y_pred - y).sum()
if e % 50 == 0:
print("Epoch {:3d} | Loss {:.4f}".format(e, loss))
# Back propagation
grad_y_pred = 2.0 * (y_pred - y)
grad_theta_l2 = a_l1.T.dot(grad_y_pred)
grad_a_l1 = grad_y_pred.dot(theta_l2.T)
grad_z_l1 = grad_a_l1.copy()
grad_z_l1[z_l1 < 0] = 0
grad_theta_l1 = x.T.dot(grad_z_l1)
# Update weights
theta_l1 -= learning_rate * grad_theta_l1
theta_l2 -= learning_rate * grad_theta_l2
# + [markdown] colab_type="text" id="4rW8kXxOF5Yv"
# To improve upon this, we will use **PyTorch**.
#
# PyTorch is a neural networks library that essentially works like Numpy on steroids. Like numpy, it has linear algebra capabilities.
# + colab={} colab_type="code" id="zrQCKbbABr8E"
import torch
# + [markdown] colab_type="text" id="SnkaP3YHGHwF"
# Here is the same example as the one above, but using PyTorch tensors.
# + colab={"base_uri": "https://localhost:8080/", "height": 203} colab_type="code" id="aon6XveV9tHE" outputId="743e3024-626b-4c9d-acf1-4370e1fc3faf"
torch.manual_seed(42)
bs, input_dim, hidden_dim, output_dim = 32, 100, 128, 10
# Create random input and output data
x = torch.randn(bs, input_dim)
y = torch.randn(bs, output_dim)
# Randomly initialize weights
theta_l1 = torch.randn(input_dim, hidden_dim)
theta_l2 = torch.randn(hidden_dim, output_dim)
learning_rate = 1e-6
epochs = 500
for e in range(1, epochs + 1):
# Forward propagation
z_l1 = x.mm(theta_l1)
a_l1 = z_l1.clamp(min=0)
y_pred = a_l1.mm(theta_l2)
# Compute for loss
loss = (y_pred - y).pow(2).sum().item()
if e % 50 == 0:
print("Epoch {:3d} | Loss {:.4f}".format(e, loss))
# Back propagation
grad_y_pred = 2.0 * (y_pred - y)
grad_theta_l2 = a_l1.t().mm(grad_y_pred)
grad_a_l1 = grad_y_pred.mm(theta_l2.t())
grad_z_l1 = grad_a_l1.clone()
grad_z_l1[z_l1 < 0] = 0
grad_theta_l1 = x.t().mm(grad_z_l1)
# Update weights
theta_l1 -= learning_rate * grad_theta_l1
theta_l2 -= learning_rate * grad_theta_l2
# + [markdown] colab_type="text" id="ygK5IhhQGMEP"
# The main advantage of using PyTorch is that it has an **autodiff** engine. When we mark a tensor with ```requires_grad=True```, we are telling PyTorch to record all the operations that the tensor undergoes. This creates a computational graph in the background that records the operational history.
#
# Instead of manually taking note of every single activation and gradient ourselves, we can let PyTorch do this for us. When we reach our loss value, we can have PyTorch automatically backprop from that point, giving us the gradients with respect to the tensors we marked as ```requires_grad=True```.
# + colab={"base_uri": "https://localhost:8080/", "height": 203} colab_type="code" id="pFJn_7GjA-OD" outputId="120b3ba8-c61d-471d-c0ee-6b327205cdcb"
torch.manual_seed(42)
bs, input_dim, hidden_dim, output_dim = 32, 100, 128, 10
# Create random input and output data
x = torch.randn(bs, input_dim)
y = torch.randn(bs, output_dim)
# Randomly initialize weights
theta_l1 = torch.randn(input_dim, hidden_dim, requires_grad=True)
theta_l2 = torch.randn(hidden_dim, output_dim, requires_grad=True)
learning_rate = 1e-6
epochs = 500
for e in range(1, epochs + 1):
# Forward propagation, chain all the operations
y_pred = x.mm(theta_l1).clamp(min=0).mm(theta_l2)
# Compute for loss
loss = (y_pred - y).pow(2).sum()
if e % 50 == 0:
print("Epoch {:3d} | Loss {:.4f}".format(e, loss))
# Backpropagation
loss.backward()
# Update the weights
with torch.no_grad():
theta_l1 -= learning_rate * theta_l1.grad
theta_l2 -= learning_rate * theta_l2.grad
# Zero-out gradients
theta_l1.grad.zero_()
theta_l2.grad.zero_()
# + [markdown] colab_type="text" id="lKxH0Fd1G3zn"
# In combination with an autodiff engine, PyTorch also has a neural networks toolkit called ```torch.nn```. This includes wrappers for many different neural network layers.
# + colab={} colab_type="code" id="I7tPIBMu9rfI"
import torch.nn as nn
# + [markdown] colab_type="text" id="ULQEqP9HHF29"
# Instead of manually creating theta parameters and operations, we can instantiate a model with one hidden layer using the neural networks toolkit.
#
# This submodule also includes many widely-used loss functions.
#
# Let's instantiate the same network using the toolkit and add a loss function that we can use. For forward propagation, we only have to call our model as a function to get our activations.
# + colab={"base_uri": "https://localhost:8080/", "height": 203} colab_type="code" id="dh65JQfACEg8" outputId="b302b641-34b3-44ea-be2b-6c3897bb6f94"
torch.manual_seed(42)
bs, input_dim, hidden_dim, output_dim = 32, 100, 128, 10
# Create random input and output data
x = torch.randn(bs, input_dim)
y = torch.randn(bs, output_dim)
# Initialize layers and a loss function
model = nn.Sequential(
nn.Linear(input_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, output_dim)
)
criterion = nn.MSELoss(reduction="sum")
learning_rate = 1e-4
epochs = 500
for e in range(1, epochs + 1):
# Forward propagation
y_pred = model(x)
# Compute for loss
loss = criterion(y_pred, y)
if e % 50 == 0:
print("Epoch {:3d} | Loss {:.4f}".format(e, loss))
# Zero-out the gradients then backpropagate
model.zero_grad()
loss.backward()
# Update the weights
with torch.no_grad():
for param in model.parameters():
param -= learning_rate * param.grad
# + [markdown] colab_type="text" id="58G9qAObHW1S"
# The last component is the optimizers submodule, which contains implementations of many different optimizers, such as gradient descent.
# + colab={} colab_type="code" id="gYI2RlNo-VsE"
import torch.optim as optim
# + [markdown] colab_type="text" id="Qe1zXVzVHdJi"
# Here is the same example, but with an optimizer handling all the gradient descent upkeep. We instantiate a gradient descent optimizer and we pass the parameter list of our model. This tells the optimizer which parameters to update during every step of gradient descent.
#
# + colab={"base_uri": "https://localhost:8080/", "height": 203} colab_type="code" id="SPfYZvsX-n6k" outputId="65e91d6a-892a-4e7c-e8fd-de6e23eab559"
torch.manual_seed(42)
bs, input_dim, hidden_dim, output_dim = 32, 100, 128, 10
# Create random input and output data
x = torch.randn(bs, input_dim)
y = torch.randn(bs, output_dim)
# Initialize layers and a loss function
model = nn.Sequential(
nn.Linear(input_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, output_dim)
)
criterion = nn.MSELoss(reduction="sum")
optimizer = optim.SGD(model.parameters(), lr=1e-4)
epochs = 500
for e in range(1, epochs + 1):
# Forward propagation
y_pred = model(x)
# Compute for loss
loss = criterion(y_pred, y)
if e % 50 == 0:
print("Epoch {:3d} | Loss {:.4f}".format(e, loss))
# Zero-out the gradients, backpropagate, then update
optimizer.zero_grad()
loss.backward()
optimizer.step()
# + [markdown] colab_type="text" id="RmpS4vltHiNN"
# Finally, we can create custom modules using PyTorch. This is the most common way that we create advanced neural networks in PyTorch.
#
# Here is our neural network as a module. We only have to add the layers as members and the module will keep track of the necessary parameters. We also have to implement a forward function.
# + colab={} colab_type="code" id="ULLXgeiY_DBZ"
class MultilayerPerceptron(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(MultilayerPerceptron, self).__init__()
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.fc2 = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
out = self.fc1(x)
out = torch.relu(out)
out = self.fc2(out)
return out
# + [markdown] colab_type="text" id="q4ApP7tRH0Oq"
# We can instantiate the model and use it like a sequential model, but with more flexibility.
# + colab={"base_uri": "https://localhost:8080/", "height": 203} colab_type="code" id="0HVKQfp7-4MC" outputId="47914bc9-d45c-4c7c-bcc2-81830d0718af"
torch.manual_seed(42)
bs, input_dim, hidden_dim, output_dim = 32, 100, 128, 10
# Create random input and output data
x = torch.randn(bs, input_dim)
y = torch.randn(bs, output_dim)
# Initialize layers and a loss function
model = MultilayerPerceptron(input_dim, hidden_dim, output_dim)
criterion = nn.MSELoss(reduction="sum")
optimizer = optim.SGD(model.parameters(), lr=1e-4)
epochs = 500
for e in range(1, epochs + 1):
# Forward propagation
y_pred = model(x)
# Compute for loss
loss = criterion(y_pred, y)
if e % 50 == 0:
print("Epoch {:3d} | Loss {:.4f}".format(e, loss))
# Zero-out the gradients, backpropagate, then update
optimizer.zero_grad()
loss.backward()
optimizer.step()
# + [markdown] colab_type="text" id="1JuNOupl_z3B"
# # MNIST in PyTorch
# + [markdown] colab_type="text" id="yIz_ktSgH-SZ"
# Let's train a neural network for the MNIST dataset using PyTorch.
#
# First, we resplit the data, then convert the numpy arrays into PyTorch tensors.
# + colab={"base_uri": "https://localhost:8080/", "height": 104} colab_type="code" id="4arbEze6_Xgu" outputId="9fbf29ac-7424-4ce7-b437-7cc015cc8ecd"
# Split the dataset
X_train, X_test, y_train, y_test = train_test_split(mnist.data.astype(np.float32),
mnist.target.astype(np.int),
random_state=42)
# Convert to PyTorch tensors
X_train = torch.from_numpy(X_train)
X_test = torch.from_numpy(X_test)
y_train = torch.from_numpy(y_train)
y_test = torch.from_numpy(y_test)
X_train.shape, X_test.shape, y_train.shape, y_test.shape
# + [markdown] colab_type="text" id="dxjIfIK0IEpp"
# We import the data utilities submodule.
# + colab={} colab_type="code" id="fLmrv2vSADb1"
import torch.utils.data as data_utils
# + [markdown] colab_type="text" id="lKa7UFq6IG_f"
# This submodule allows easy batching. There are many ways to implement custom dataloaders for minibatching, but here is the simplest way.
# + colab={} colab_type="code" id="rKJy-a7n_4WT"
# Dataloading
bs = 32
# Create tensor datasets
train_data = data_utils.TensorDataset(X_train, y_train)
test_data = data_utils.TensorDataset(X_test, y_test)
# Pass the datasets and a batch size to create a loader
train_loader = data_utils.DataLoader(train_data, batch_size=bs)
test_loader = data_utils.DataLoader(test_data, batch_size=bs)
# + [markdown] colab_type="text" id="gv3BWQ1eIRZE"
# This functions the same way as a generator.
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="xE1LkedJACHN" outputId="fc947a80-27af-4893-fbbc-9d9eac658b33"
train_list = [b for b in train_loader]
x, y = train_list[0]
print(x.shape, y.shape)
print(len(train_list))
# + [markdown] colab_type="text" id="oeFUimJmIURM"
# Here is the first batch.
# + colab={"base_uri": "https://localhost:8080/", "height": 186} colab_type="code" id="bVFdWjoRAKXV" outputId="686db1e3-35ec-4330-e5a9-b1568e4b4eff"
print(x)
print(y)
# + [markdown] colab_type="text" id="V58NAKm8IVhb"
# Let's write our model again as a module.
# + colab={} colab_type="code" id="4aSDW3PVAMOJ"
#architecture
class MultilayerPerceptron(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(MultilayerPerceptron, self).__init__()
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.fc2 = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
out = self.fc1(x)
out = torch.relu(out)
out = self.fc2(out)
return out
# + [markdown] colab_type="text" id="UqOxXX3cIZKF"
# And write a new accuracy helper function the works with PyTorch.
# + colab={} colab_type="code" id="VuE5fbZWAVRe"
def accuracy(y_pred, y):
return torch.sum(torch.max(y_pred, 1)[1] == y).item() / len(y)
# + [markdown] colab_type="text" id="9t25US1nIceI"
# We instantiate a model, a loss function, and an optimizer.
# + colab={} colab_type="code" id="I5LGtli4AX44"
model = MultilayerPerceptron(input_dim=784, hidden_dim=128, output_dim=10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=6e-5)
# + [markdown] colab_type="text" id="S8-CUpnhIpUj"
# Then we train for 10 epochs again.
# + colab={"base_uri": "https://localhost:8080/", "height": 699} colab_type="code" id="86Jc2Bc2AZaz" outputId="0e3cb865-9162-4705-b7b7-01db0df7067f"
epochs = 10
for e in range(1, epochs + 1):
train_loss = 0
train_acc = 0
for batch in tqdm(train_loader):
x, y = batch
y_pred = model(x)
loss = criterion(y_pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_loss += loss.item()
train_acc += accuracy(y_pred, y)
train_loss /= len(train_loader)
train_acc /= len(train_loader)
test_loss = 0
test_acc = 0
for batch in tqdm(test_loader):
x, y = batch
with torch.no_grad():
y_pred = model(x)
loss = criterion(y_pred, y)
test_loss += loss.item()
test_acc += accuracy(y_pred, y)
test_loss /= len(test_loader)
test_acc /= len(test_loader)
print("\nEpoch {:3d} | Train Loss {:.4f} | Test Loss {:.4f} | Train Acc {:.2f}% | Test Acc {:.2f}%".format(e, train_loss, test_loss, train_acc * 100, test_acc * 100))
# + [markdown] colab_type="text" id="YV21A7nQIsOh"
# We can test a sample batch of test data.
# + colab={"base_uri": "https://localhost:8080/", "height": 54} colab_type="code" id="kippptogAceY" outputId="2c8a6ba7-5742-45d6-83e1-32e8fb0a3d1d"
x, y = train_list[10]
y_pred = model(x)
loss = criterion(y_pred, y)
acc = accuracy(y_pred, y)
print("Loss {:.4f} | Accuracy {:.2f}%".format(loss.item(), acc * 100))
# + [markdown] colab_type="text" id="vdPKVJOXItQa"
# Here are the network's predictions.
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="suOjFOkgAmlQ" outputId="fe54fa13-89ae-420d-8d71-f6dd8816861a"
torch.max(y_pred, 1)[1]
# + [markdown] colab_type="text" id="E--gJNkQIynJ"
# And the correct labels for each data sample.
# + colab={"base_uri": "https://localhost:8080/", "height": 71} colab_type="code" id="TkqzVmbwAvUy" outputId="03e76636-5031-4ebb-8250-ac6e5f4df4d1"
y
# + colab={} colab_type="code" id="nONgrDO3AwgE"
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
from selenium import webdriver
from bs4 import BeautifulSoup
import os
from selenium.webdriver.firefox.options import Options as FirefoxOptions
import itertools
import time
import re
import logging
import json
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.NullHandler())
class GGParser(object):
def __init__(self, width=1920, height=1080, headless=False, driver_path=None,
screenshots_enabled=True, screenshot_directory='.screenshots'):
if driver_path is None:
driver_path = os.path.join("golfgenius", "drivers", "firefox", "0.28", "geckodriver")
self.screenshots_enabled = screenshots_enabled
self.screenshot_directory = os.path.abspath(screenshot_directory)
self.screenshot_count = 0
if screenshots_enabled:
if not os.path.isdir(self.screenshot_directory):
os.makedirs(self.screenshot_directory)
options = FirefoxOptions()
if headless:
options.add_argument("--headless")
self.driver = webdriver.Firefox(
service_log_path=os.path.devnull,
options=options,
executable_path=os.path.abspath(driver_path))
self.driver.set_window_size(width, height)
self.base_url = 'https://www.golfgenius.com/'
self.login_url = self.base_url + "golfgenius"
logger.debug("opened FireFox driver")
self.landing_page = None
def screenshot(self, name=None):
if self.screenshots_enabled:
self.screenshot_count += 1
logger.debug("Creating screenshot #{} ({})".format(self.screenshot_count, name))
try:
pngdata = self.driver.get_screenshot_as_png()
if name is None:
fname = os.path.join(self.screenshot_directory, 'screenshot-{}.png'.format(self.screenshot_count))
else:
fname = os.path.join(self.screenshot_directory, '{}.png'.format(name))
with open(fname, 'wb') as fp:
fp.write(pngdata)
logger.debug("Created screenshot {}".format(fname))
except:
logger.error("Unable to save screenshot", exc_info=True)
else:
logger.debug("Ignoring screenshot {}".format(name))
def close(self):
logger.debug("closing FireFox driver")
return self.driver.close()
def sign_in(self, ggid):
login_url = self.login_url
logger.debug("Opening %s" % login_url)
self.driver.get(login_url)
time.sleep(2)
logger.debug("Signing in")
login_button = self._get_element(self.soup.find('a', text='SIGN IN'))
login_button.click()
time.sleep(1)
ggid_input = self._get_element(self.soup.find('input', {u"placeholder": u"Enter Your GGID", u"type": u"text"}))
ggid_input.clear()
ggid_input.send_keys(ggid)
sign_in_button = self._get_element(self.soup.find('input', type="submit", value="Sign In"))
self.screenshot(name="sign_in")
sign_in_button.click()
time.sleep(5)
sign_in_button2 = self._get_element(self.soup.find('input', type="submit", value="Sign In"))
self.screenshot(name="sign_in__select_name")
sign_in_button2.click()
logger.debug("Waiting 5 secs")
time.sleep(5)
logger.debug("Sign In Complete")
def _parse_tournaments(self):
results = {}
logger.debug("Finding tournament IDs")
tournaments = self._get_all_tournament_ids()
tournament_ids = [_id for _id, name in tournaments]
teams = self._get_teams(tournament_ids)
assert teams is not None, "Unable to parse teams"
results["teams"] = teams
logger.debug("populating scores..")
self._populate_scores(tournament_ids, results)
return results
def _populate_scores(self, tournament_ids, results):
logger.debug("Parsing all scores")
results["scores"] = {}
for tournament_id in tournament_ids:
self.driver.get(self.base_url + "tournaments2/details?adjusting=false&event_id=%s" % tournament_id)
logger.debug("waiting 3 seconds")
table = self.soup.find('table', {"class": "scorecard"})
if table:
m = re.search("(\d+)\?round_index=(\d+)", tournament_id)
if m:
event_id = m.group(1)
round_index = m.group(2)
else:
event_id = self.screenshot_count + 1
round_index = tournament_id
self.screenshot("round-{}-{}".format(round_index, event_id))
for player_row in [tr for tr in table.find_all('tr', {"class": "net-line"}) if tr.attrs.get("data-net-name") is not None]:
player_name = player_row.attrs["data-net-name"].strip()
if player_name not in results["scores"]:
logger.debug("Creating scores for %s" % player_name)
results["scores"][player_name] = {}
results["scores"][player_name]["scores"] = {}
for score in player_row.find_all('td', {'class': 'score'}):
hole, value_int, score_type = None, None, None
hole_list = [a for a in score.attrs["class"] if a.startswith('hole')]
if len(hole_list) == 1:
hole = hole_list[0].replace("hole", "")
value = score.find('div', {"class": "single-score"}).text.strip()
if value.isdigit():
value_int = int(value)
type_list = [a for a in score.attrs["class"] if a.endswith('-hole')]
if len(type_list) == 1:
score_type = type_list[0].replace('-hole', '')
if hole is not None and value_int is not None and score_type is not None:
if hole not in results["scores"][player_name]["scores"]:
results["scores"][player_name]["scores"][hole] = {"score": value_int, "type": score_type}
logger.debug("recorded score for %s hole %s: %s" % (player_name, hole, results["scores"][player_name]["scores"][hole]))
def _get_teams(self, tournament_ids):
logger.debug("looking up teams..")
teams = []
for tournament_id in tournament_ids:
self.driver.get(self.base_url + "tournaments2/details?adjusting=false&event_id=%s" % tournament_id)
logger.debug("waiting 3 seconds")
time.sleep(3)
table = self.soup.find('table', {"class": "scorecard"})
if table:
for tr in table.find_all("tr", {"class": "aggregate_score"}):
if "data-aggregate-name" in tr.attrs:
team_str = tr.attrs["data-aggregate-name"]
team = [x.strip() for x in team_str.split("+")]
logger.debug("Found team: %s" % team)
teams.append(team)
if teams:
return teams
def _get_all_tournament_ids(self):
logger.debug("Finding tournaments")
tournaments = [(t.attrs["href"].split('/')[-1], t.text.strip()) for t in self.soup.find_all('a', {"class": "expand-tournament"})]
logger.debug("Found %s tournaments" % len(tournaments))
return tournaments
def _get_round_options(self, filter=None):
results_link = self.soup.find('a', text=re.compile(r"\s*Results\s*"))
results_button = self._get_element(results_link)
logger.debug("Clicking results_button")
results_button.click()
logger.debug("Waiting 5 seconds")
time.sleep(5)
results_landing_page = self.driver.current_url
logger.debug("Switching to iframe")
self.driver.switch_to.frame("page_iframe")
logger.debug("Waiting for 3 seconds")
time.sleep(3)
logger.debug("Finding Rounds")
seen = {}
select_element = self.soup.find(id='round')
all_options = select_element.find_all('option')
if isinstance(filter, re.Pattern):
filtered_options = [option for option in all_options if filter.match(option.text.strip()) is not None]
logger.info("Discovered {} rounds matching pattern {}. ({} total)".format(
len(filtered_options), filter.pattern, len(all_options)
))
else:
filtered_options = all_options
logger.info("Discovered {} rounds.".format(
len(filtered_options)))
return filtered_options
def iter_rounds(self, ggid, filter=None):
"""
:param ggid: Golf Genius ID
:param filter: Optional compiled re to match against round names to pull
:return: results as dict
"""
try:
logger.info("Logging into {}".format(self.login_url))
self.sign_in(ggid)
logger.debug("Loading results")
self.landing_page = self.driver.current_url
filtered_options = self._get_round_options(filter=filter)
for option in filtered_options:
round_name = option.text.strip()
round_id = option.attrs["value"]
if round_id in seen:
continue
logger.debug("Parsing round %s (%s)" % (round_name, round_id))
self._get_element(option).click()
try:
seen[round_id] = True
round_results = self._parse_tournaments()
player_count = len(round_results.get("scores", {}))
logger.info("Stored {} ({} players)".format(round_name, player_count))
yield round_name, {"name": round_name, "results": round_results}
except Exception as exc:
import traceback
logger.critical("Error parsing round %s" % round_name, exc_info=True)
seen[round_id] = True
finally:
logger.debug("Reloading results landing page")
self.driver.get(results_landing_page)
self.driver.switch_to.default_content()
logger.debug("Switching back to iframe")
self.driver.switch_to.frame("page_iframe")
finally:
pass
def parse(self, ggid, filter=None):
"""
:param ggid: Golf Genius ID
:param filter: Optional compiled re to match against round names to pull
:return: results as dict
"""
try:
logger.info("Logging into {}".format(self.login_url))
self.sign_in(ggid)
self.screenshot(name="sign_in")
logger.debug("Loading results")
self.landing_page = self.driver.current_url
results_link = self.soup.find('a', text=re.compile(r"\s*Results\s*"))
results_button = self._get_element(results_link)
logger.debug("Clicking results_button")
results_button.click()
logger.debug("Waiting 5 seconds")
time.sleep(5)
self.screenshot(name="results")
results_landing_page = self.driver.current_url
logger.debug("Switching to iframe")
self.driver.switch_to.frame("page_iframe")
logger.debug("Waiting for 3 seconds")
time.sleep(3)
logger.debug("Finding Rounds")
results = {}
select_element = self.soup.find(id='round')
for option in select_element.find_all('option'):
round_name = option.text.strip()
round_id = option.attrs["value"]
if round_id in results:
continue
if isinstance(filter, re.Pattern) and filter.match(round_name) is None:
logger.info("Ignoring round {0} due to filter {1}".format(round_name, str(filter.pattern)[:50]))
continue
logger.debug("Parsing round %s (%s)" % (round_name, round_id))
self._get_element(option).click()
self.screenshot(name="round %s" % round_name)
try:
results[round_id] = {
"name": round_name,
"results": self._parse_tournaments()
}
logger.info("Parsed {}".format(round_name))
except Exception as exc:
import traceback
logger.critical("Error parsing round %s" % round_name, exc_info=True)
results[round_id] = {
"name": round_name,
"results": {},
"error": str(exc),
"traceback": traceback.format_exc()
}
finally:
logger.debug("Reloading results landing page")
self.driver.get(results_landing_page)
self.driver.switch_to.default_content()
logger.debug("Switching back to iframe")
self.driver.switch_to.frame("page_iframe")
return results
finally:
self.screenshot("parse_final")
def _get_element(self, e):
xpath = self.xpath_soup(e)
return self.driver.find_element_by_xpath(xpath)
@property
def soup(self):
return BeautifulSoup(self.driver.page_source, "html.parser")
def xpath_soup(self, element):
"""
Generate xpath of soup element
:param element: bs4 text or node
:return: xpath as string
"""
components = []
child = element if element.name else element.parent
for parent in child.parents:
"""
@type parent: bs4.element.Tag
"""
previous = itertools.islice(parent.children, 0, parent.contents.index(child))
xpath_tag = child.name
xpath_index = sum(1 for i in previous if i.name == xpath_tag) + 1
components.append(xpath_tag if xpath_index == 1 else '%s[%d]' % (xpath_tag, xpath_index))
child = parent
components.reverse()
return '/%s' % '/'.join(components)
def to_json(self, ggid, path, filter=None):
""" Parses results and saves as json files to output_dir.
:param ggid: Golf Genius ID
:param path: Directory to save json files to
:param filter: A compiled regex filter
:return: None
"""
assert os.path.isdir(path), "output_dir must be a directory"
results = self.parse(ggid, filter=filter)
for round_id, result in results.items():
with open(os.path.join(path, "%s.json" % result["name"]), "w") as fp:
json.dump(result, fp, indent=4)
# -
parser = GGParser(headless=False, screenshots_enabled=False)
parser.sign_in("nzxmej")
filtered_options = parser._get_round_options(filter=".*April.*")
filtered_options
option = filtered_options[0]
round_name = option.text.strip()
round_id = option.attrs["value"]
round_name, round_id
parser._get_element(option).click()
tournaments = parser._get_all_tournament_ids()
tournaments
tournament_id = tournaments[0]
tournament_id
tourneys = parser.soup.find_all('a', {'class': 'expand-tournament'})
tourneys[0]
parser._get_element(tourneys[0]).click()
link = parser.soup.find('a', {"class": "expand-all"})
parser._get_element(link).click()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
import h2o
h2o.init()
air = h2o.upload_file(h2o.locate("smalldata/airlines/allyears2k_headers.zip"))
air.dim()
numNAs = air["DepTime"].isna().sum()
print numNAs
DepTime_mean = air["DepTime"].mean(na_rm=True)
print DepTime_mean
air.impute("DepTime", method = "median", combine_method="low")
numNAs = air["DepTime"].isna().sum()
print numNAs
air = h2o.upload_file(h2o.locate("smalldata/airlines/allyears2k_headers.zip"))
air.impute("DepTime", method = "mean", by = ["Origin", "Distance"]).show()
air = h2o.upload_file(h2o.locate("smalldata/airlines/allyears2k_headers.zip"))
air.impute("TailNum", method = "mode").show()
air = h2o.upload_file(h2o.locate("smalldata/airlines/allyears2k_headers.zip"))
air.impute("TailNum", method = "mode", by=["Month", "Year"]).show()
|
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.14.4
# kernelspec:
# display_name: python3
# language: python
# name: python3
# ---
# # Tune a CNN on MNIST
#
# This tutorial walks through using Ax to tune two hyperparameters (learning rate and momentum) for a PyTorch CNN on the MNIST dataset trained using SGD with momentum.
#
# +
import torch
import numpy as np
from ax.plot.contour import plot_contour
from ax.plot.trace import optimization_trace_single_method
from ax.service.managed_loop import optimize
from ax.utils.notebook.plotting import render, init_notebook_plotting
from ax.utils.tutorials.cnn_utils import load_mnist, train, evaluate, CNN
init_notebook_plotting()
# -
torch.manual_seed(12345)
dtype = torch.float
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# ## 1. Load MNIST data
# First, we need to load the MNIST data and partition it into training, validation, and test sets.
#
# Note: this will download the dataset if necessary.
BATCH_SIZE = 512
train_loader, valid_loader, test_loader = load_mnist(batch_size=BATCH_SIZE)
# ## 2. Define function to optimize
# In this tutorial, we want to optimize classification accuracy on the validation set as a function of the learning rate and momentum. The function takes in a parameterization (set of parameter values), computes the classification accuracy, and returns a dictionary of metric name ('accuracy') to a tuple with the mean and standard error.
def train_evaluate(parameterization):
net = CNN()
net = train(net=net, train_loader=train_loader, parameters=parameterization, dtype=dtype, device=device)
return evaluate(
net=net,
data_loader=valid_loader,
dtype=dtype,
device=device,
)
# ## 3. Run the optimization loop
# Here, we set the bounds on the learning rate and momentum and set the parameter space for the learning rate to be on a log scale.
best_parameters, values, experiment, model = optimize(
parameters=[
{"name": "lr", "type": "range", "bounds": [1e-6, 0.4], "log_scale": True},
{"name": "momentum", "type": "range", "bounds": [0.0, 1.0]},
],
evaluation_function=train_evaluate,
objective_name='accuracy',
)
# We can introspect the optimal parameters and their outcomes:
best_parameters
means, covariances = values
means, covariances
# ## 4. Plot response surface
#
# Contour plot showing classification accuracy as a function of the two hyperparameters.
#
# The black squares show points that we have actually run, notice how they are clustered in the optimal region.
render(plot_contour(model=model, param_x='lr', param_y='momentum', metric_name='accuracy'))
# ## 5. Plot best objective as function of the iteration
#
# Show the model accuracy improving as we identify better hyperparameters.
# `plot_single_method` expects a 2-d array of means, because it expects to average means from multiple
# optimization runs, so we wrap out best objectives array in another array.
best_objectives = np.array([[trial.objective_mean*100 for trial in experiment.trials.values()]])
best_objective_plot = optimization_trace_single_method(
y=np.maximum.accumulate(best_objectives, axis=1),
title="Model performance vs. # of iterations",
ylabel="Classification Accuracy, %",
)
render(best_objective_plot)
# ## 6. Train CNN with best hyperparameters and evaluate on test set
# Note that the resulting accuracy on the test set might not be exactly the same as the maximum accuracy achieved on the evaluation set throughout optimization.
data = experiment.fetch_data()
df = data.df
best_arm_name = df.arm_name[df['mean'] == df['mean'].max()].values[0]
best_arm = experiment.arms_by_name[best_arm_name]
best_arm
combined_train_valid_set = torch.utils.data.ConcatDataset([
train_loader.dataset.dataset,
valid_loader.dataset.dataset,
])
combined_train_valid_loader = torch.utils.data.DataLoader(
combined_train_valid_set,
batch_size=BATCH_SIZE,
shuffle=True,
)
net = train(
net=CNN(),
train_loader=combined_train_valid_loader,
parameters=best_arm.parameters,
dtype=dtype,
device=device,
)
test_accuracy = evaluate(
net=net,
data_loader=test_loader,
dtype=dtype,
device=device,
)
print(f"Classification Accuracy (test set): {round(test_accuracy*100, 2)}%")
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.