Interview Prep
Career
GenAI
Prompt Engg
ChatGPT
LLM
Langchain
RAG
AI Agents
Machine Learning
Deep Learning
GenAI Tools
LLMOps
Python
NLP
SQL
AIML Projects

Reading list

6 Steps of Machine learning Lifecycle Introduction to Predictive Modeling
Introduction to Exploratory Data Analysis & Data Insights Descriptive Statistics Inferential Statistics How to Understand Population Distributions?
Reading Data Files into Python Different Variable Datatypes
Probability for Data Science Basic Concepts of Probability Axioms of Probability Conditional Probability
Central Tendencies for Continuous Variables Spread of Data KDE plots for Continuous Variable Overview of Distribution for Continuous variables Normal Distribution Skewed Distribution Skeweness and Kurtosis Distribution for Continuous Variable
Central Tendencies for Categorical Variables Understanding Discrete Distributions Performing EDA on Categorical Variables
Dealing with Missing Values Understanding Outliers Identifying Outliers in Data Outlier Detection in Python Outliers Detection Using IQR, Z-score, LOF and DBSCAN
Sample and Population Central Limit Theorem Confidence Interval and Margin of Error
Bivariate Analysis Introduction
Covariance Pearson Correlation Spearman's Correlation & Kendall's Tau Correlation versus Causation Tabular and Graphical methods for Bivariate Analysis Performing Bivariate Analysis on Continuous-Continuous Variables
Tabular and Graphical methods for Continuous-Categorical Variables Introduction to Hypothesis Testing P-value Two sample Z-test T-test T-test vs Z-test Performing Bivariate Analysis on Continuous-Catagorical variables
Chi-Squares Test Bivariate Analysis on Categorical Categorical Variables
Multivariate Analysis A Comprehensive Guide to Data Exploration The Data Science behind IPL
Supervised Learning vs Unsupervised Learning Reinforcement Learning Generative and Descriminative Models Parametric and Non Parametric model
Machine Learning Pipeline Preparing Dataset Build a Benchmark Model: Regression Build a Benchmark Model: Classification
Evaluation Metrics for Machine Learning Everyone should know Confusion Matrix Accuracy Precision and Recall AUC-ROC Log Loss R2 and Adjusted R2
Dealing with Missing Values Replacing Missing Values Imputing Missing Values in Data Working with Categorical Variables Working with Outliers Preprocessing Data for Model Building
Understanding Cost Function Understanding Gradient Descent Math Behind Gradient Descent Assumptions of Linear Regression Implement Linear Regression from Scratch Train Linear Regression in Python Implementing Linear Regression in R Diagnosing Residual Plots in Linear Regression Models Generalized Linear Models Introduction to Logistic Regression Odds Ratio Implementing Logistic Regression from Scratch Introduction to Scikit-learn in Python Train Logistic Regression in python Multiclass using Logistic Regression How to use Multinomial and Ordinal Logistic Regression in R ? Challenges with Linear Regression Introduction to Regularisation Implementing Regularisation Ridge Regression Lasso Regression
Introduction to K Nearest Neighbours Determining the Right Value of K in KNN Implement KNN from Scratch Implement KNN in Python
Bias Variance Tradeoff Introduction to Overfitting and Underfitting Visualizing Overfitting and Underfitting Selecting the Right Model What is Validation? Hold-Out Validation Understanding K Fold Cross Validation
Introduction to Feature Selection Feature Selection Algorithms Missing Value Ratio Low Variance Filter High Correlation Filter Backward Feature Elimination Forward Feature Selection Implement Feature Selection in Python Implement Feature Selection in R
Introduction to Decision Tree Purity in Decision Tree Terminologies Related to Decision Tree How to Select Best Split Point in Decision Tree? Chi-Squares Information Gain Reduction in Variance Optimizing Performance of Decision Tree Train Decision Tree using Scikit Learn Pruning of Decision Trees
Introduction to Feature Engineering Feature Transformation Feature Scaling Feature Engineering Frequency Encoding Automated Feature Engineering: Feature Tools
Understanding how to solve Multiclass and Multilabled Classification Problem Evaluation Metrics: Multi Class Classification
Introduction to Ensemble Techniques Basic Ensemble Techniques Implementing Basic Ensemble Techniques Finding Optimal Weights of Ensemble Learner using Neural Network Why Ensemble Models Work well?
Introduction to Stacking Implementing Stacking Variants of Stacking Implementing Variants of Stacking Introduction to Blending Bootstrap Sampling Introduction to Random Sampling Hyper-parameters of Random Forest Implementing Random Forest Out-of-Bag (OOB) Score in the Random Forest IPL Team Win Prediction Project Using Machine Learning Introduction to Boosting Gradient Boosting Algorithm Math behind GBM Implementing GBM in python Regularized Greedy Forests Extreme Gradient Boosting Implementing XGBM in python Tuning Hyperparameters of XGBoost in Python Implement XGBM in R/H2O Adaptive Boosting Implementing Adaptive Boosing LightGBM Implementing LightGBM in Python Catboost Implementing Catboost in Python
Different Hyperparameter Tuning methods Implementing Different Hyperparameter Tuning methods GridsearchCV RandomizedsearchCV Bayesian Optimization for Hyperparameter Tuning Hyperopt
Understanding SVM Algorithm SVM Kernels In-depth Intuition and Practical Implementation SVM Kernel Tricks Kernels and Hyperparameters in SVM Implementing SVM from Scratch in Python and R
Introduction to Principal Component Analysis Steps to Perform Principal Compound Analysis Computation of Covariance Matrix Finding Eigenvectors and Eigenvalues Implementing PCA in python Visualizing PCA A Brief Introduction to Linear Discriminant Analysis Introduction to Factor Analysis
Introduction to Clustering Applications of Clustering Evaluation Metrics for Clustering Understanding K-Means Implementation of K-Means in Python Implementation of K-Means in R Choosing Right Value for K Profiling Market Segments using K-Means Clustering Hierarchical Clustering Implementation of Hierarchial Clustering DBSCAN Defining Similarity between clusters Build Better and Accurate Clusters with Gaussian Mixture Models
Understand Basics of Recommendation Engine with Case Study
8 Ways to Improve Accuracy of Machine Learning Models
Introduction to Dask Working with CuML
Introduction to Machine Learning Interpretability Framework and Interpretable Models model Agnostic Methods for Interpretability Implementing Interpretable Model Understanding SHAP Out-of-Core ML Introduction to Interpretable Machine Learning Models Model Agnostic Methods for Interpretability Game Theory & Shapley Values
Introduction to AutoML Implementation of MLBox Introduction to PyCaret TPOT Auto-Sklearn EvalML
Pickle and Joblib Introduction to Model Deployment
Deploying Machine Learning Model using Streamlit Deploying ML Models in Docker Deploy Using Streamlit Deploy on Heroku Deploy Using Netlify Introduction to Amazon Sagemaker Setting up Amazon SageMaker Using SageMaker Endpoint to Generate Inference Deploy on Microsoft Azure Cloud Introduction to Flask for Model Deploying ML model using Flask
Model Deployment in Android Model Deployment in Iphone

Git Reset vs Revert: When to Use Each Command?

Shikha Sen
Shikha Sen 18 Jun, 2024
6 min read

Introduction

In the world of version control systems, mistakes are bound to happen. Whether you accidentally reset your branch to the wrong commit or removed vital changes, Git provides a robust mechanism to recover from such scenarios. This guide delves into the intricacies of Git reset vs. revert operations, empowering you to undo unintended changes and restore your repository to its desired state.

Overview

  • Understand the key differences between Git reset and revert operations and their appropriate use cases.
  • Learn the different modes of Git reset (soft, mixed, hard) and their effects on the branch pointer, staging area, and working directory.
  • Master the techniques for reversing Git reset operations, including soft, mixed, and hard resets.
  • Gain practical knowledge of common errors and troubleshooting methods when reversing a Git reset.
  • Recognize the importance of preventive measures such as frequent commits, backups, and using Git stash to safeguard against accidental resets or other mistakes.

Table of contents

What is Git Reset?

Before we dive into reversing a reset, it’s essential to understand the underlying concept of the `git reset` command. This command is primarily used to undo local changes and move the branch pointer (HEAD) to a different commit. Depending on the options used, `git reset` can discard committed changes, unstaged changes, or both.

Git reset [<mode>][<commit>]]

In addition to perhaps updating the index (resetting it to the tree of <commit> ) and the working tree, depending on <mode>, this form resets the current branch head to <commit>. ORIG_HEAD is set to the current branch tip prior to the operation. —mixed is the default if [<mode>] is not specified. The following must be the case for the : Soft, reset or Mixed

Modes of Opernation in Git Reset

There are different modes of operation for `git reset`, but soft mixed and hard are the three main modes: 

  1. Soft Reset: Moves the branch pointer to the specified commit, but keeps the changes in the staging area and the working directory. It does not touch the index file  and working tree at all , but resets the head to <commit>.
  2. Mixed Reset (default): Moves the branch pointer and resets the staging area to match the specified commit, but leaves the working directory unchanged and therefore resetting the index and not the working tree.
  3. Hard Reset: Moves the branch pointer, resets the staging area, and overwrites the working directory with the specified commit. It resets the index and working tree.
[Additional Operation] Merge: Resets the index and updates the working tree’s files that differ between and HEAD, while preserving the files that differ between the index and working tree (i.e., containing unadded changes). Reset is terminated in the event that unstaged changes exist in a file that differs between and the index.

Also Read: A Comprehensive Guide to Common Git Commands in Data Science

Reversing a Git Reset

Reversing a Git reset involves undoing the effects of the `git reset` command. The process varies depending on the mode used and the desired outcome. Here are the common scenarios and their respective solutions:

Reversing a Soft Reset

A soft reset is relatively straightforward to reverse since it preserves the changes in the staging area and working directory. To undo a soft reset, you can use the `git reset` command with the `–soft` option, followed by the commit hash you want to restore:

#bash
$ git reset --soft <commit-hash>
#This command will move the branch pointer back to the specified commit, effectively reverting the soft reset.

This command will move the branch pointer back to the specified commit, effectively reverting the soft reset.

Example :  git soft 

Undo a commit and redo

$ git commit ...
$ git reset --soft HEAD^      (1)
$ edit                        (2)
$ git commit -a -c ORIG_HEAD  (3)

If you do not need to edit the message further, you can give -C option instead.

Reversing a Mixed Reset

In a mixed reset, the staging area is reset, but the changes remain in the working directory. To reverse this reset, you can first unstage the changes using `git reset HEAD`, and then create a new commit with the unstaged changes:

```bash
$ git reset HEAD
$ git add .
$ git commit -m "Reverting mixed reset"

This process effectively reverses the mixed reset by creating a new commit with the previously unstaged changes.

Reversing a Hard Reset

Example : 

Undo a commit, making it a subject branch

$ git branch subject/wip          (a)
$ git reset --hard HEAD~3       (b)
$ git switch subject/wip          (c)
  • You realise that some of the commits you made were premature to be in the master branch. Make a topic/wip branch out of the current HEAD so you can continue refining them there.
  • To remove those three commits, rewind the master branch.
  • Continue working by switching to the subject/wip branch.

A hard reset is the most destructive form of reset, as it overwrites the working directory with the specified commit. Reversing a hard reset requires recreating the lost changes from a backup or reverting to an older commit if available.

If you have a backup or a stash of your changes, you can apply them to the current branch:

#bash
$ git stash apply

Alternatively, if you have an older commit that contains the desired changes, you can revert to that commit using `git reset` or `git revert`:

# Using git reset (destructive)
$ git reset <older-commit-hash>

# Using git revert (non-destructive)
$ git revert <commit-hash-to-revert>

Git Revert: Revert Some Existing Commits

The `git revert` command creates a new commit that undoes the changes introduced by the specified commit, effectively reversing its effects.

Example :

$git revert HEAD~3

Revert the changes specified by the fourth last commit in HEAD and create a new commit with the reverted changes.

Note: To undo the effects of some previous commits (usually just a bad one), use git revert to record some new changes. You should see git-reset[1], especially the –hard option, if you want to erase all uncommitted changes in your working directory. You should be able to access git-restore[1], specifically the –source option, if you wish to extract individual files as they were in a previous commit. Use caution when utilising these options as they will both remove any uncommitted modifications from your working directory.

Common Errors and Troubleshooting

While reversing a Git reset, you might encounter some common errors and issues. Here are a few scenarios and their respective solutions:

  • Error “Cannot revert”: When you see an error message such as “Cannot revert as the given commit has already been reverted,” it indicates that the commit you are attempting to undo has already been undone on the current branch. To carry out the revert action in this situation, you can either checkout an alternative branch or establish a new branch.
  • Resolving Merge Conflicts: Reversing a Git reset could occasionally result in merge conflicts. This happens when there is a conflict between the changes that you are trying to rollback and other commits in the repository. You must manually edit the files that are at odds, take out the conflict markers, and stage the resolved changes before committing in order to resolve merge conflicts.
  • Recovering Lost Commits: If you’ve accidentally lost commits due to a hard reset or force-pushed a branch, you can attempt to recover the lost commits using the `git reflog` command. This command displays a log of all the commit references in the repository, including those that are no longer part of any branch.
$ git reflog

Locate the commit hash of the lost commit, and then create a new branch pointing to that commit:

$ git branch <new-branch-name> <commit-hash>

This will create a new branch with the recovered commit, allowing you to continue working or merge the changes back into your main branch.

Conclusion

Git reset is a powerful tool for undoing changes and managing the state of your repository. However, reversing a Git reset can be a complex task, especially when dealing with hard resets or lost commits. By understanding the different modes of Git reset vs. revert operations and their corresponding reversal techniques, you can confidently undo unintended changes and restore your repository to its desired state.

Remember, prevention is always better than cure. It’s advisable to commit your changes frequently, create backups, and use Git’s stash feature to ensure you can easily recover from accidental resets or other mistakes.

Frequently Asked Questions

Q1. What does git reset do?

A. Git reset moves the current branch to a specified commit, optionally modifying the index and working directory.

Q2. What is the difference between git reset and merge?

A. Git reset changes the commit history, whereas git merge combines changes from different branches without altering history.

Q3. What is the difference between git commit –amend and git reset?

A. Git commit –amend modifies the last commit, while git reset changes the commit history and branch pointer.

Q3. What is git reset vs. soft reset vs. hard reset?

A. Git reset changes the branch reference. A soft reset alters the commit history but keeps changes staged, while a hard reset updates the commit history, index, and working directory.

Git Reset vs RevertGithub
Shikha Sen
Shikha Sen 18 Jun, 2024

With 4 years of experience in model development and deployment, I excel in optimizing machine learning operations. I specialize in containerization with Docker and Kubernetes, enhancing inference through techniques like quantization and pruning. I am proficient in scalable model deployment, leveraging monitoring tools such as Prometheus, Grafana, and the ELK stack for performance tracking and anomaly detection. My skills include setting up robust data pipelines using Apache Airflow and ensuring data quality with stringent validation checks. I am experienced in establishing CI/CD pipelines with Jenkins and GitHub Actions, and I manage model versioning using MLflow and DVC. Committed to data security and compliance, I ensure adherence to regulations like GDPR and CCPA. My expertise extends to performance tuning, optimizing hardware utilization for GPUs and TPUs. I actively engage with the LLMOps community, staying abreast of the latest advancements to continually improve large language model deployments. My goal is to drive operational efficiency and scalability in AI systems.

Free Courses

image.name 4.7

Generative AI - A Way of Life

Explore Generative AI for beginners: create text and images, use top AI tools, learn practical skills, and ethics.
image.name 4.5

Getting Started with Large Language Models

Master Large Language Models (LLMs) with this course, offering clear guidance in NLP and model training made simple.
image.name 4.6

Building LLM Applications using Prompt Engineering

This free course guides you on building LLM apps, mastering prompt engineering, and developing chatbots with enterprise data.
image.name 4.8

Building Your first RAG System using LlamaIndex

Build your first RAG model with LlamaIndex in this free course. Dive into Retrieval-Augmented Generation now!
image.name 4.7

Building Production Ready RAG systems using LlamaIndex

Learn Retrieval-Augmented Generation (RAG): learn how it works, the RAG framework, and use LlamaIndex for advanced systems.

Recommended Articles

Frequently Asked Questions

Lorem ipsum dolor sit amet, consectetur adipiscing elit,

Write for us

Write, captivate, and earn accolades and rewards for your work
  • Reach a Global Audience
  • Get Expert Feedback
  • Build Your Brand & Audience
  • Cash In on Your Knowledge
  • Join a Thriving Community
  • Level Up Your Data Science Game
imag
Rahul Shah img

Rahul Shah

27
Sion Chakrabarti img

Sion Chakrabarti

16
CHIRAG GOYAL img

CHIRAG GOYAL

87
kaustubh gupta img

kaustubh gupta

24
Barney Darlington img

Barney Darlington

5
Suvojit Hore img

Suvojit Hore

9
Arnab Mondal img

Arnab Mondal

15