You wouldn’t drive a car without brakes…\n\nOr skydive without a parachute…\n\nThen why shoulder digital transformation without the guard rails?\n\nGet INVIGRID on your side

Invi Grid

Food and Flavor: A Gastronomic Guide to Health and Good Living: Chapter IV 

SECONDARY SEXUAL CHARACTERS IN THE LOWER CLASSES OF THE ANIMAL KINGDOM

Miriam

HOW I BECAME A LONDON STUDENT AND WENT ASTRAY

The Effectiveness of AI and ML on Supply Chains Amidst a Global Pandemic

Here is a quick guide on how to Install Gitea with on Debian 11 Postgresql Start with a quick system update: sudo apt-get update -y
sudo apt-get upgrade -y Setup postgresql sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'

# Import repo signing key with:
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -

sudo apt-get update
sudo apt-get -y install postgresql System setup sudo systemctl start postgresql
sudo systemctl enable postgresql
sudo systemctl status postgresql Next, You need to switch to ’SCRAM-SHA-256’ scheme from md5 encryption scheme for better security. If you want to connect to PostgreSQL remotely, then you need to allow your IP address in the PostgreSQL configuration file. Open the configuration file to make changes using the following command: sudo vim /etc/postgresql/15/main/postgresql.conf

# Inside file uncomment:

listen_addresses = 'localhost, 45.32.225.46'
password_encryption = scram-sha-256 Then, restart the systemd service: sudo systemctl restart postgresql Login into postgresql sudo -u postgres psql Inside psql: postgres=# CREATE ROLE gitea WITH LOGIN PASSWORD 'secure@123';

postgres=# CREATE DATABASE giteadb;

postgres=# GRANT ALL PRIVILEGES ON DATABASE giteadb TO gitea;

postgres=# exit if you receive the error: The database settings are invalid: migrate: sync: pq: permission denied for schema public you might have to do the following in psql after the install is complete, I did: ALTER DATABASE gitea OWNER TO gitea Within /etc/postgresql/15/main/pghba.conf file: host    giteadb        gitea            134.122.38.0/32           scram-sha-256 Install and configure git: sudo apt install git
git --version

git config --global user.name "Your Name"
git config --global user.email "youremail@domain.com”
git config --list Create git user for gitea sudo adduser \
   --system \
   --shell /bin/bash \
   --gecos 'Git Version Control' \
   --group \
   --disabled-password \
   --home /home/git \
   git Install gitea: wget https://dl.gitea.com/gitea/1.20.3/gitea-1.20.3-linux-amd64 -O /usr/local/bin/gitea
sudo chmod +x /usr/local/bin/gitea Make directory structure for gitea: sudo mkdir -p /etc/gitea

sudo mkdir -p /var/lib/gitea/{custom,data,indexers,public,log}

sudo chown -R git:git /var/lib/gitea/

sudo chown root:git /etc/gitea

sudo chmod -R 750 /var/lib/gitea/

sudo chmod 770 /etc/gitea Create systemd service file: sudo vim /etc/systemd/system/gitea.service Inside: [Unit]
Description=Gitea
After=syslog.target
After=network.target
After=postgresql.service

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/gitea/
ExecStart=/usr/local/bin/gitea web -c /etc/gitea/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl start gitea
sudo systemctl enable gitea
sudo systemctl status gitea

# Verify running on port 3000:
netstat -tulpan | grep 3000 Navigate to port 3000 on your server and you will see it running! Congrats, you have now dropped GitHub as your Git server. Also published here.

Step-by-Step Guide for Installing Gitea on Debian 11

In the realm of machine learning and data science, feature engineering stands as a cornerstone of model performance improvement. While algorithms and models often grab the spotlight, it's the carefully crafted features that lay the foundation for predictive power. Imagine trying to build a house on a weak foundation – without strong features, even the most advanced algorithms may crumble when faced with complex datasets. Understanding Feature Engineering Feature engineering is the creative and strategic process of selecting, transforming, and creating features (input variables) from raw data to maximize a model's performance. It's the art of converting data into actionable insights, giving machines the contextual understanding they need to make accurate predictions. Whether it's predicting house prices, classifying customer preferences, or diagnosing medical conditions, feature engineering holds the key to unlocking the potential hidden within your data. The Importance of Careful Craftsmanship Imagine you're tasked with predicting house prices based on a variety of factors. You might initially be drawn to the obvious features like square footage, number of bedrooms, and location. However, the magic of feature engineering lies in unearthing the subtler aspects that influence the target variable. Does the ratio of bathrooms to bedrooms impact the price? What about the presence of a fireplace or the age of the roof? Feature engineering isn't merely about creating more features; it's about discerning which facets of the data truly matter. This process often requires domain knowledge, creativity, and a deep understanding of the problem you're tackling. By refining existing features and crafting new ones, you're essentially teaching your model to understand the data like an expert. Why should you care about feature engineering? The answer lies in model performance. Well-engineered features can lead to faster convergence during training, reduced overfitting, and ultimately, more accurate predictions. A machine learning model is only as good as the data it's fed, and well-engineered features provide a richer, more nuanced representation of that data. In this article, we'll delve into the world of feature engineering using the advanced house price prediction dataset from Kaggle. By following along, you'll gain insights into various techniques that can transform raw data into valuable predictors and you’ll see how the results of your model improve by applying different feature engineering methods. So, without wasting anytime, let’s start learning about the different methods of feature engineering. Methods Now that we have set the stage, it's time to delve into the exciting world of advanced feature engineering techniques. In this section, I'll guide you through the step-by-step implementation of four powerful methods that can supercharge your predictive models. Each method serves a unique purpose, offering insights and improvements that can make a substantial difference in your model's performance. Method 1: Mutual Information - Extracting Information from Relationships Imagine being able to select the most influential features for your model with surgical precision. Mutual Information allows you to achieve just that. By quantifying the relationship between each feature and the target variable, you can identify the key factors that impact your predictions. We'll walk you through the code and provide a detailed explanation of every step, helping you master this insightful technique. Method 2: Clustering - Discovering Patterns through Grouping Clusters often hide valuable patterns within your data. With clustering, you can uncover these hidden gems and leverage them to enhance your model's understanding. I'll guide you through the process of applying KMeans clustering to group similar instances together. You'll learn how to create new features based on these clusters and observe their impact on model performance. Method 3: PCA Dimensionality Reduction - Condensing Complexity High-dimensional data can be overwhelming, but Principal Component Analysis (PCA) offers a solution. By identifying the most influential dimensions, you can reduce complexity without sacrificing predictive power. This tutorial will lead you through the transformation of your data using PCA, providing insights into how this technique can streamline your model while retaining its accuracy. In addition to these methods, I'll also introduce you to —an often overlooked technique that can wield powerful results. By applying mathematical operations to selected columns, you can shape your data to better align with your model's assumptions. You'll explore logarithmic, square root, and inverse transformations, illustrating how they can uncover hidden relationships and boost your model's accuracy. Mathematical Transformations Throughout this section, I'll offer comprehensive explanations to ensure that you not only grasp the technical aspects but also understand the reasoning behind each method's application. By the end, you'll have gained a valuable toolkit of advanced feature engineering techniques that can be confidently applied to enhance your predictive models in various scenarios. Are you ready to explore the intricacies of each method, uncover their potential, and equip yourself with the expertise to engineer features that translate to more accurate and powerful predictive models? Let's begin this enlightening journey! Code Importing Packages Let’s first import all the packages that you need. import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.feature_selection import SelectKBest, mutual_info_regression
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.preprocessing import LabelEncoder, StandardScaler
import numpy as np Getting The Data Now, let’s get the dataset from kaggle and preprocess it. # Load the dataset
data = pd.read_csv('train.csv')

# Data preprocessing
def preprocess_data(df):
    # Handle missing values
    df = df.fillna(df.median())

    # Handle categorical variables
    df = pd.get_dummies(df, drop_first=True)

    return df

data = preprocess_data(data)

# Prepare the data
X = data.drop('SalePrice', axis=1)
y = data['SalePrice']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) To start, let's run a baseline model without any feature engineering and assess its accuracy. After that, we'll apply each of the four feature engineering methods (mutual information, clustering, PCA dimensionality reduction, and label encoding) individually and compare their effects on model performance. Base Line Model Before applying any feature engineering, we'll start with a baseline model. Here, we'll use a simple linear regression model to predict house prices using the original dataset. baseline_model = LinearRegression()
baseline_model.fit(X_train, y_train)
baseline_predictions = baseline_model.predict(X_test)
baseline_rmse = mean_squared_error(y_test, baseline_predictions, squared=False)
print(f"Baseline RMSE: {baseline_rmse}")

# ------------------ OUTPUT ---------------- #
Baseline RMSE: 49204.92 In the baseline model, you're starting with a simple linear regression model that uses the original features as they are. You're training the model using the training data, making predictions on the test data, and calculating the root mean squared error (RMSE) to measure how well the model performs on unseen data. Mutual Information Model # Method 1: Mutual Information
mi_selector = SelectKBest(score_func=mutual_info_regression, k=10)
X_train_mi = mi_selector.fit_transform(X_train, y_train)
X_test_mi = mi_selector.transform(X_test)
mi_model = LinearRegression()
mi_model.fit(X_train_mi, y_train)
mi_predictions = mi_model.predict(X_test_mi)
mi_rmse = mean_squared_error(y_test, mi_predictions, squared=False)
print(f"Mutual Information RMSE: {mi_rmse}")

# ------------------ OUTPUT ----------------- #
Mutual Information RMSE: 39410.99 Here, you're exploring the information each feature provides about the target variable. You select the top 10 features that have the highest mutual information scores with the target. Then, you train a new linear regression model using only these selected features. This helps ensure that your model focuses on the most informative features, and you calculate the RMSE to see how this model's predictions compare to the baseline. Clustering Model # Method 2: Clustering
num_clusters = 5
kmeans = KMeans(n_clusters=num_clusters, random_state=42)
X_clustered = X.copy()
X_clustered['Cluster'] = kmeans.fit_predict(X)
X_clustered = pd.get_dummies(X_clustered, columns=['Cluster'], prefix='Cluster')
X_train_clustered, X_test_clustered, _, _ = train_test_split(X_clustered, y, test_size=0.2, random_state=42)
cluster_model = LinearRegression()
cluster_model.fit(X_train_clustered, y_train)
cluster_predictions = cluster_model.predict(X_test_clustered)
cluster_rmse = mean_squared_error(y_test, cluster_predictions, squared=False)
print(f"Clustering RMSE: {cluster_rmse}")

# ------------------- OUTPUT -------------- #
Clustering RMSE: 47715.30 You're looking at grouping similar instances in your data using clustering. Specifically, you use the KMeans algorithm to divide your data into clusters. Each instance is assigned to a cluster, and you add this cluster information as a new categorical feature. By doing this, you're giving the model a way to consider the relationships between instances in terms of their clusters. After training a linear regression model on this clustered data, you calculate the RMSE to evaluate its performance. PCA - Dimensionality Reduction Model # Method 3: PCA Dimensionality Reduction
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train)
pca = PCA(n_components=10)
X_train_pca = pca.fit_transform(X_scaled)
X_test_pca = pca.transform(scaler.transform(X_test))
pca_model = LinearRegression()
pca_model.fit(X_train_pca, y_train)
pca_predictions = pca_model.predict(X_test_pca)
pca_rmse = mean_squared_error(y_test, pca_predictions, squared=False)
print(f"PCA RMSE: {pca_rmse}")

# --------------- OUTPUT -------------- #
PCA RMSE: 40055.78 PCA helps you reduce the complexity of your data by summarizing it into fewer dimensions. You standardize your data to make sure all features are on the same scale. Then, you use PCA to identify the most important patterns in your data and reduce the number of features to 10 principal components. Training a linear regression model on these components, you're able to capture the most significant information while simplifying the model. The RMSE helps you gauge if this approach is effective. Mathematical Transformations Model # Method 5: Mathematical Transformations
X_train_transformed = X_train.copy()
X_test_transformed = X_test.copy()

# Apply logarithmic transformation
log_columns = ['GrLivArea', 'LotArea']  # Specify columns to apply log transformation
X_train_transformed[log_columns] = np.log1p(X_train_transformed[log_columns])
X_test_transformed[log_columns] = np.log1p(X_test_transformed[log_columns])

# Apply square root transformation
sqrt_columns = ['GarageArea', '1stFlrSF']  # Specify columns to apply square root transformation
X_train_transformed[sqrt_columns] = np.sqrt(X_train_transformed[sqrt_columns])
X_test_transformed[sqrt_columns] = np.sqrt(X_test_transformed[sqrt_columns])

# Apply inverse transformation
inv_columns = ['YearBuilt', 'OverallQual']  # Specify columns to apply inverse transformation
X_train_transformed[inv_columns] = 1 / X_train_transformed[inv_columns]
X_test_transformed[inv_columns] = 1 / X_test_transformed[inv_columns]

math_transform_model = LinearRegression()
math_transform_model.fit(X_train_transformed, y_train)
math_transform_predictions = math_transform_model.predict(X_test_transformed)
math_transform_rmse = mean_squared_error(y_test, math_transform_predictions, squared=False)
print(f"Mathematical Transformations RMSE: {math_transform_rmse}")

# ------------------ OUTPUT --------------- #
Mathematical Transformations RMSE: 47143.21 Mathematical transformations involve altering feature values using mathematical operations to bring out underlying patterns. You apply logarithmic, square root, and inverse transformations to specific columns. For example, logarithmic transformation helps normalize skewed data, square root transformation can help with outliers, and inverse transformation can emphasize relationships with small values. You train a linear regression model using these transformed features and calculate the RMSE to assess whether the transformations have improved the model's predictive power. In all these methods, you're experimenting with different techniques to make your data more suitable for modeling. The goal is to find the method that leads to the lowest RMSE, indicating that your model's predictions are closer to the actual target values and hence more accurate. Comparing Results This is the root mean squared error (RMSE) of the baseline model, where no feature engineering or transformation has been applied. The model uses the original features as they are. An RMSE of 49204.92 indicates the average prediction error of the baseline model on the test data. Baseline RMSE: 49204.92 This RMSE represents the performance of the model after applying the mutual information feature selection method. It's significantly lower than the baseline RMSE, indicating that selecting the top k features based on their mutual information scores has led to improved model performance. Mutual Information RMSE: 39410.99 The RMSE here corresponds to the model's performance after introducing a new categorical feature based on clustering. The RMSE is close to the baseline RMSE, suggesting that the introduction of clustering did not lead to a significant improvement in this case. Clustering RMSE: 47715.30 This RMSE reflects the performance of the model after applying PCA for dimensionality reduction. It's a bit higher than the mutual information RMSE but lower than the baseline RMSE. The model using PCA-transformed features seems to perform moderately well. PCA RMSE: 40055.78 The RMSE here shows the performance of the model when categorical variables are label encoded. The RMSE matches the baseline RMSE, indicating that using label encoded features didn't lead to a noticeable improvement in this case. Label Encoding RMSE: 49204.92 This RMSE represents the performance of the model after applying various mathematical transformations to selected columns. The RMSE is lower than the baseline RMSE, suggesting that these transformations have led to improved model performance. Mathematical Transformations RMSE: 47143.21 In summary: seems to be the most effective feature selection method among the methods tried, as it significantly reduced the RMSE. Mutual Information and both resulted in improved model performance compared to the baseline. PCA Mathematical Transformations did not show a significant improvement in this particular scenario. Clustering Keep in mind that the actual RMSE values and their interpretation depend on various factors such as the dataset, the complexity of the model, and the nature of the target variable. The goal is to experiment with different feature engineering methods and select the one that leads to the best performance on unseen data.

The Beginner's Guide to Feature Engineering

La guía para principiantes de ingeniería de características

Le guide du débutant pour l'ingénierie des fonctionnalités

फ़ीचर इंजीनियरिंग के लिए शुरुआती मार्गदर्शिका

特徴量エンジニアリングの初心者ガイド

O guia para iniciantes em engenharia de recursos

Hướng dẫn dành cho người mới bắt đầu về Kỹ thuật tính năng

特征工程初学者指南

All through this smaller-than-expected series, we'll make our own personal Instagram duplicate, called Instapics. This little application allows you to post, as, and remark on photographs, as well as follow different clients. Considering that, how about we make a plunge! Stage 1: Download Laravel and Other Project Files Before we start, we should initially guarantee that we have a framework that can uphold Laravel. As indicated by the documentation, Laravel requires the accompanying: - Laravel utilizes a ton of PHP 5.3-explicit elements, similar to terminations, late-static restricting, and namespaces. PHP 5.3.x - is empowered of course in PHP 5.3, however, on Windows frameworks, you could have to add the augmentation in your PHP.ini design record. The FileInfo library - this is utilized by Laravel for encryption and hash age, and ordinarily comes pre-introduced with PHP. Mcrypt library Whenever we're finished setting up the climate, we should download Laravel and every one of the libraries we'll use for Instapics. Download the accompanying documents and spot them inside a web-open envelope: - (Currently v3.2.1) Laravel - (Currently v2.0.4) Twitter Bootstrap - (Currently v1.7.2) jQuery Inside Laravel's root envelope, you'll track down a public organizer - this is where all freely open records ought to be put away. Laravel v3.2.1 has some premade organizers inside the public envelope for our resources, CSS, img, and js organizers. Place the Twitter Bootstrap and jQuery documents in their comparing envelopes. Stage 2: Setup Laravel's Encryption Key, Pretty URLs, and Virtual Host Before we compose any code, we want to set an encryption key for Laravel to use for our application. Laravel utilizes this to encode any information we could require encryption for, like treats. Open the application/config/application.php record and track down the key setting. Inside, the default worth will be YourSecretKeyGoesHere!. Then, open up a Terminal/Command Prompt, peruse Laravel's root catalog, and use Artisan to create a key: PHP craftsman key: create This ought to naturally produce an irregular 32-character encryption key for . Assuming that you did this accurately, it ought to now seem to be the accompanying: Laravel To recover your key, simply rehash the means! Then, we want to change the arrangement so it can acknowledge pretty URLs and work even without guiding our solicitations toward index.php. In the application/config/application.php record, search for the accompanying: Assuming you're utilizing this, you want to guarantee that you have mod_rewrite empowered on your web server (if you're on Apache). Finally, we'll have to set up a virtual host for Laravel. This isn't required for an improvement climate, at the same time, for creation, we mustn't permit admittance to the Laravel library and application documents. As referenced above, in the Laravel documents you ought to see an organizer, called public, which is where all freely open records ought to go Designing a virtual host relies upon which web server you're utilizing. Here is a model for the Apache Web Server: We ought to likewise add the area, instapics.com, to our host's records (since this space doesn't exist). In Windows, alter the document C:\Windows\System32\drivers\etc\hosts; in Linux/OSX, you normally alter/and so on/has. Add this line to the document: 127.0.0.1 instapics.com This will illuminate our machine that the space instapics.com will set out to 127.0.0.1, which is the neighborhood PC. Stage 3: Setup Routing In Laravel, all solicitations to the application are planned to explicit capacities or regulators by Routes. They are answerable for training the application where URLs go. For instance, assuming we needed http://instapics.com/home to deliver the home view record, we can make the accompanying course inside routes.php, tracked down inside the application envelope: On the other hand, if we rather need to course http://instapics.com/home to a Controller, say, the home.php regulator, we could follow through with something like this: Route::controller('home'); This would course to the home.php regulator document. Any activity strategy there will be made accessible also. Something imperative to note here is that as a matter of course, Laravel doesn't course to the regulators as other PHP structures do. This is by the plan. Thusly, we can make basic pages without the need to make a regulator for them. For instance, to make a static Contact Us page that rundowns down contact data, we can just follow through with something like this: Route::any('contact-us', work() { return View::make('home.contact-us'); }) This will course http://instapics.com/get in touch with us and render the application/sees/home/contact-us.php record. Since we have no powerful handling on this page, we can just naturally deliver the view record, saving us an opportunity to make and design a regulator to do such. There is quite a lot more that we can do with Routes in Laravel that it can remain all alone as its instructional exercise. Stuff like: - Laravel empowers us to take courses, in light of the HTTP action word that was utilized in the solicitation. For instance, we can have a GET solicitation to the/home course head off to some place not the same as where the POST solicitation would go. HTTP Verbs - this allows us to the highway a URL with special case esteem joined to it (for example /client/(: num) where (: num) is the client's ID) Trump cards - these let us run some usefulness previously or after a course is executed, contingent upon the course that was called. For instance, we can make an auth channel that will be called before all courses, except the home, and about courses. In CodeIgniter, these are like Hooks, however a lot more straightforward to carry out, because the channels depend on the courses - so we can execute them for all solicitations or simply some. Channels For this web application, however, we just need two or three courses. Initial, a course that maps all solicitations to regulators naturally. Open up the routes.php document, and remark out the default course to the Home regulator: Beneath this piece of code, add the accompanying line: Route::controller(Controller::detect()); This line will plan every one of our solicitations to every one of the regulators. There is no such thing as if the regulator or activities, the framework will return a 404 reaction. Presently, we make a course for http://instapics.com/about. We can simply make an about regulator, yet that would be a loss since we can just put that inside the Home regulator. Add the accompanying line after the course we recently made: Route::controller(Controller::detect()); Route::get('about', 'home@about'); This course will guide all solicitations to http://instapics.com/going to the Home regulator, and the About activity. Stage 3. Make your First Laravel Controller Regulators in Laravel are tracked down inside the application/regulators organizer. Of course, the Home regulator will acknowledge demands shipped off the base of the Laravel application. For instance, going to http://instapics.com/will go to the Home->action_index() technique. To make a regulator, essentially make a document inside the application/regulators envelope. By show, we'll need to name the record something illustrative that will likewise be the name of the regulator class. Until further notice, we should make another regulator for our login system, called "Login": Then, open your program and visit http://instapics.com/login. From here, you ought to see the "test" troubleshooting message that we put. Since, in the routes.php document, we set it to empower courses to every one of the regulators, this ought to work with next to no extra arrangement. Whenever you've affirmed that it's working, simply eliminate the troubleshooting message. We'll get back to this regulator in a future article. For the present, salute yourself; you've quite recently made your most memorable Laravel regulator!

Step by Step Guide to Build the Laravel Web App

INVI GRID

invigrid.com

-- employees

Since n.d.

COMPANY RANKING

INVI GRID

EVERGREEN INDEX #5730

Representing this company? Click here to claim and customize this page!

Invi Grid WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

INVI GRID

invigrid.com

-- employees

Since n.d.

COMPANY RANKING

INVI GRID

EVERGREEN INDEX #5730

RELATED COMPANIESRANK

STORIES ABOUT INVI GRID

Representing this company? Click here to claim and customize this page!

Invi Grid WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!