User Question

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import RocCurveDisplay, roc_curve, auc
from xgboost import XGBClassifier # xgboost version 1.7.6
import matplotlib.pyplot as plt

# Data available on kaggle here https://www.kaggle.com/datasets/uciml/red-wine-quality-cortez-et-al-2009/
data = pd.read_csv('winequality-red.csv')
data.head()

# Separate targets
X = data.drop('quality', axis=1)
y = data['quality'].map(lambda x: 1 if x >= 7 else 0) # wine quality >7 is good, rest is not good

# Split into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create model and fit
params = {
    'eval_metric':'auc',
    'objective':'binary:logistic'
}
model = XGBClassifier(**params)
model.fit(
    X_train,
    y_train,
    eval_set=[(X_test, y_test)]
)

results = model.evals_result()
plt.plot(np.arange(0,100),results['validation_0']['auc'])
plt.title("AUC from eval_set")
plt.xlabel("Estimator (boosting round)")
plt.ylabel("AUC")

test_predictions = model.predict(X_test)
fpr, tpr, thresholds = roc_curve(y_true=y_test, y_score=test_predictions,pos_label=1)
roc_auc = auc(fpr, tpr)
display = RocCurveDisplay(roc_auc=roc_auc, fpr=fpr, tpr=tpr)
display.plot()

My Answer

test_probabs = model.predict_proba(X_test)[:, 1]
fpr, tpr, thresholds = roc_curve(y_true=y_test, y_score=test_probabs, pos_label=1)
roc_auc = auc(fpr, tpr)
display = RocCurveDisplay(roc_auc=roc_auc, fpr=fpr, tpr=tpr)
display.plot()

Link to StackOverflow question

User Question

My Answer

Morphological transformations are some simple operations based on the image shape. It is normally performed on binary images. It needs two inputs, one is our original image, second one is called structuring element or kernel which decides the nature of operation. Two basic morphological operators are Erosion and Dilation. Then its variant forms like Opening, Closing, Gradient etc also comes into play. We will see them one-by-one with help of following image.

Closing is reverse of Opening, Dilation followed by Erosion. It is useful in closing small holes inside the foreground objects, or small black points on the object.

import cv2
import numpy as np

img = cv2.imread('<path_to_your_image>',0)
kernel = np.ones((5,5),np.uint8)

closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

Link to StackOverflow question

User Question

dict = {"a" : 1, "b" : 2}

if 'Dictionary key' == "a":
return True
else:
return False

My Answer

my_dict = {"a" : 1, "b" : 2}
for key in my_dict:
print(key)

a
b

my_dict = {"a" : 1, "b" : 2}
for key in my_dict:
if key == "a":
    return True
else:
    return False

my_dict = {"a" : 1, "b" : 2}
print("a" in my_dict.keys())

my_dict = {"a" : 1, "b" : 2}
for key in my_dict:
print(my_dict[key])

1
2

Link to StackOverflow question

User Question

words = ['hello', 'world', 'name', '1', '2018']

My Answer

words = ['hello', 'world', 'name', '1', '2018']
valid_years = {str(x) for x in range(2000,2021)}

for word in words:
if word in valid_years:
    print word

Sets let you test for membership in O(1) time, using a list has a linear O(length_of_list) cost

• List comprehension
• Sets
• Complexities for different Python data structures(so you can understand which data structures in Python are quicker for specific operations)

Link to StackOverflow question

User Question

My Answer

When support for time zones is enabled, Django stores datetime information in UTC in the database, uses time-zone-aware datetime objects internally, and translates them to the end user’s time zone in templates and forms.
Time zone support is disabled by default.

# enable time zone support
USE_TZ = True

# select a timezone
TIME_ZONE = 'Europe/Rome'

Link to StackOverflow question

User Question

My Answer

1. List item you want to copy to your test database to populate it using fixtures. This will only create a db with the needed data instead of stupidly copying the entire db. It will be stored in a .yaml file.

generate.py

django.setup()
stdout = sys.stdout

conf = [
{
    'file': 'myfile.yaml',
    'models': [
        dict(model='your.model', pks='your, primary, keys'),
        dict(model='your.model', pks='your, primary, keys')
    ]
}
]

for fixture in conf:
print('Processing: %s' % fixture['file'])
with open(fixture['file'], 'w') as f:
    sys.stdout = FixtureAnonymiser(f)

for model in fixture['models']:
    call_command('dumpdata', model.pop('model'), format='yaml',indent=4, **model)
    sys.stdout.flush()

sys.stdout = stdout



2. In your test unit, import your generated .yaml file as a fixture and your test will automatically use this the data from the fixture to carry out the tests, keeping your main database untouched.

test_class.py

from django.test import TestCase

class classTest(TestCase):

fixtures = ('myfile.yaml',)

def setUp(self):
    """setup tests cases"""
   # create the object you want to test here, which will use data from the fixtures

def test_function(self):
    self.assertEqual(True,True)
    # write your test here

• Django
• YAML

Link to StackOverflow question