We often hear the saying, ‘Teamwork makes the dream work.’ But does this concept apply to AI as well? Is it possible that combining multiple LLMs could result in better and faster responses? Could LLMs operate on the principle of ‘Divide and Conquer’ to optimize their performance? These questions have been on my mind recently.

Curious, I ran a small experiment. While working on a set of questions, I wanted faster responses. So, I tried using different LLMs for different parts of the task — and surprisingly, the results came in quicker. Each model handled a specific block, and together, they outpaced a single model working alone. Fascinating, right?

Why Did this work?

The success of the experiment got me thinking — was it due to token-per-minute limitations, or do multiple LLMs actually complement each other?. Apparently, it seems like most LLMs are trained on vast datasets, but they still develop strengths and weaknesses. Some are better at factual recall, while others excel at creative writing or problem-solving. By dividing the task into smaller parts and assigning each model to the area it handles best, I unintentionally created an AI team — where each “teammate” played to its strengths. Isn’t this interesting to notice? This realization was striking: even AI, like humans, performs better when tasks are divided efficiently.

Apparently, for the same reason it is actually advisable to keep prompts for the LLM to be short and to the point. When the LLM prompt exceeds a certain limitat, it appears to face the problem of hallucination. This could also be because LLMs are essentially transformers, and their attention mechanisms would have been jeopardized when we give them too many instructions.

The Divide and Conquer Strategy in AI

Ahh, again we are back to our DSA class. Understanding all these algorithms. Evidently, dividing a complex task into smaller and more manageable pieces is what works in AI as well. This could be due to multiple reasons:

• Smaller prompts tailored to specific tasks result in more relevant, high-quality responses.
• Different models can work simultaneously on separate parts of a task, reducing response time.

Basically, we created a powerful team — like the Avengers — where superheroes combine their unique powers for a greater outcome.By leveraging different types of intelligence and created an architecture with multiple models:

• Model A — Great at summarizing complex information.
• Model B — Strong at creative generation and phrasing.
• Model C — Expert at fact-checking or providing technical details.

Individually, each model has blind spots. Together, they cover for one another, producing responses that are not only faster but more accurate and nuanced.

Here is the Python code for plotting the graph showing the comparison of average response times for Case 1 — where all the three models were same with Case 2 — which used a combination of different models.

import matplotlib.pyplot as plt
import numpy as np

# Data for Case 1 and Case 2
x_labels_case1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
model1_case1 = [0.43, 0.986466, 0.190241, 0.173561, 0.336204, 0.253013, 0.204127, 5.047971, 0.310801, 0.213484]
model2_case1 = [23.401517, 4.092776, 18.999459, 5.986792, 9.521706, 13.6195, 43.721286, 12.749018, 7.95277, 9.120764]
model3_case1 = [2.110472, 4.574461, 4.597078, 2.824468, 16.169483, 2.062155, 3.891042, 3.305207, 5.735195, 57.138562]

x_labels_case2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
model1_case2 = [0.286384, 0.232897, 0.237311, 0.25821, 0.216052, 0.243387, 0.158544, 0.352585, 0.246721, 0.252649]
model2_case2 = [17.495792, 9.731949, 6.361989, 4.899729, 5.199543, 6.430908, 64.843112, 4.980411, 12.679339, 11.60478]
model3_case2 = [1.868402, 1.726916, 3.097865, 2.197605, 1.498171, 1.592312, 3.160078, 2.001775, 2.075913, 3.977281]

# Average of response times for Case 1
avg_case1_model1 = np.mean(model1_case1)
avg_case1_model2 = np.mean(model2_case1)
avg_case1_model3 = np.mean(model3_case1)
avg_case1 = (avg_case1_model1 + avg_case1_model2 + avg_case1_model3) / 3

# Average of response times for Case 2
avg_case2_model1 = np.mean(model1_case2)
avg_case2_model2 = np.mean(model2_case2)
avg_case2_model3 = np.mean(model3_case2)
avg_case2 = (avg_case2_model1 + avg_case2_model2 + avg_case2_model3) / 3

# Create x labels for average comparisons
x_labels_avg = ['Case 1', 'Case 2']

# Data for plotting
averages = [avg_case1, avg_case2]

# Plotting the comparison
plt.figure(figsize=(8, 5))
plt.plot(x_labels_avg, averages, marker='o', linestyle='-', color='b', label="Average Response Time")
plt.fill_between(x_labels_avg, 0, averages, color='skyblue', alpha=0.3)

# Customize the plot
plt.title("Comparison of Average Response Times (Case 1 vs Case 2)")
plt.xlabel("Case Type")
plt.ylabel("Average Response Time (s)")
plt.grid(True, axis='y', linestyle='--', alpha=0.7)
plt.legend(loc='upper right')
plt.tight_layout()
plt.show()

As represented by the graph, the average response time came down in the case where a combination of models were used.

Potential Applications: Where Can This Approach Shine?

Use cases of this approach could essentially be in Research Assistance, Customer Support or Code Generation.

• Customer Support: A fast-response bot handles FAQs, while a more empathetic model deals with complex or emotional queries.
• Research Assistance: One model summarizes studies, another analyzes data, and a third helps formulate insights.
• Code Generation: One model writes code, another optimizes for performance, and a third checks for errors.

Given that this industry is growing every single day, and the specifics of the models are becoming better and better. This approach can be used wherever and whenever.

The Challenges: Is It All Smooth Sailing?

Well, is there anything that we can get without having a little tradeoff? This approach comes with a higher compute power and yes higher costs. But this becomes essential when dealing with healthcare or finance data. Furthermore, while multiple models can process tasks in parallel, managing their outputs and stitching them into a coherent final answer requires smart orchestration.

Final Thoughts: Is the Future of AI Collaborative?

My experiment left me with more questions than answers — but one thing is clear: combining LLMs taps into something powerful. It shifts the narrative from “Which model is the best?” to “How can different models work together to achieve more?”

So, could AI teamwork truly make the dream work? Based on what I’ve seen so far, it’s not just possible — it might be inevitable.

Assume we are in the late 90s, when Google was just released. The hype surrounding Google was overwhelming, with many viewing it as a god-like entity, and there’s evidence online that even reasoned why Google was considered “God.”

Is Google God?

Large Language Models (LLMs) are deep-learning models trained on vast amounts of data, often described as being trained on an “infinite” amount of information. This is the standard definition you’ll come across on the web, though usually phrased more elegantly. But how do we really understand what an LLM is? Today, much like the overwhelming hype around Google in its early days, people are treating LLMs almost like divine entities, believing they can answer any question. But what’s the science and reasoning behind this widespread belief? Let’s break it down.

Introducing Lazy Learner Mike: A Curious Mind

To understand what an LLM is, let’s imagine it as a person — Lazy Learner Mike. So Mike is a curious guy who wants to understand what is happening all over the world without scrambling newspapers or watching news with his Dad all night, he would rather play video games and have some way of still fetching all information. How exactly would Mike plan on doing this now?

Mike’s Plan: Building a Deep Learning Model

Mike is no ordinary guy. He’s incredibly smart, skilled in coding, math, and stats, and has a sharp eye for patterns. Instead of reading everything manually, Mike decides to create a deep learning model based on the Transformer architecture (don’t worry, not the robots from the movies!). His goal is to use this model to perform pattern matching and retrieve information in response to his questions.

Discovering Vectorization: Turning Words into Numbers

To his surprise, Mike stumbles upon vectorization — a technique introduced by one of his university seniors. Basically, turning words into numbers so a computer can understand them, just like a student turning notes into formulas for solving problems. Vectorization is essentially a form of pattern matching, where the model converts words and sentences into numerical data (vectors), making it easier to identify and process patterns in language. With this, Mike realizes that pattern matching is an ideal way to fetch relevant responses to his questions, based on a vast amount of data.

The Learning Process: How the Model Gets Smarter

As Mike continues his journey with his deep learning model, he realizes that the key to getting better responses isn’t just about gathering more data, but also about understanding how the model “learns” from that data. Just like Mike uses vectorization to turn the world’s knowledge into patterns he can easily process, LLMs also take vast amounts of text, break it down into patterns, and then “learn” from them.

Trial and Error: Continuous Improvement of the Model

The more Mike practices asking his model questions, the more it begins to refine its responses, understanding context, nuances, and even more complex queries over time. Similarly, LLMs are trained on huge datasets to recognize language patterns, structure, and meaning, allowing them to generate responses that are coherent and contextually relevant. While Mike’s curiosity drives his learning, LLMs use their training and patterns to continually improve, making them powerful tools for finding information, just like Mike’s model was designed to help him avoid reading everything manually.

The Final Outcome: A Model That Fetches Information Like a Pro

In the end, Mike’s model, much like LLMs, isn’t perfect at first. It learns through trial and error, continually improving its ability to understand and respond based on the patterns it has identified. And just as Mike can now rely on his model to fetch answers to his questions without sifting through piles of information, we can rely on LLMs to help us process and generate human-like responses based on the vast knowledge they’ve absorbed.

Conclusion: How This Relates to LLMs Today

In conclusion, Large Language Models (LLMs) are much like Mike’s deep learning model — constantly learning from the vast amounts of data they’re trained on and improving over time. Just as Mike’s model helps him find answers more easily, LLMs help us by understanding and responding to our questions based on patterns they’ve learned. While these models are still evolving, they hold the potential to make information retrieval faster and more efficient, just like having a super-smart assistant at your fingertips that gets smarter everytime you talk to it.

End Note: The Future of LLMs

As with any technology, LLMs are still evolving. While they’re powerful tools today, they will only continue to improve as they learn from more data and refine their understanding. Who knows? In the future, LLMs might be just as integral to our daily lives as Google was in the late 90s.

Learning Machine Learning along with cloud computing often seems daunting. However, a platform where innovation meets simplicity Amazon SageMaker is a cloud-based machine-learning platform that simplifies model creation, training, and deployment. It accelerates workflows, offers cost-efficiency, and scales seamlessly.

The goal of this project was to build and deploy a Random-Forest multi-class classifier model on AWS SageMaker to predict mobile phone price ranges. The first step of the project was to understand the dataset given. The dataset was a collection of mobile phone features along with their corresponding price ranges.

Each row represents a different mobile phone, and the columns contain various attributes and specifications for each phone. This dataset contains mobile phone attributes and the label that we need to predict was Price_Range of the phone.

• battery_power: Battery capacity.
• blue: Bluetooth availability (0 or 1).
• clock_speed: Processor clock speed.
• dual_sim: Dual SIM card support (0 or 1).
• fc: Front camera megapixels.
• four_g: 4G network support (0 or 1).
• int_memory: Internal memory (GB).
• m_dep: Mobile depth (thickness).
• mobile_wt: Mobile phone weight.
• n_cores: Number of processor cores.
• pc: Primary camera megapixels.
• px_height: Pixel resolution height.
• px_width: Pixel resolution width.
• ram: RAM capacity.
• sc_h: Screen height.
• sc_w: Screen width.
• talk_time: Talk time (hours).
• three_g: 3G network support (0 or 1).
• touch_screen: Touch screen availability (0 or 1).
• wifi: Wi-Fi availability (0 or 1).
• price_range: Target variable representing mobile phone price range.

In summary, the dataset includes various features that characterize mobile phones, and the goal appears to be predicting the price range based on these features. The target variable (price_range) is categorical, indicating different price ranges as follows:

• Low Price Range (Label 0)
• Medium Price Range (Label 1)
• High Price Range (Label 2)
• Very High Price Range (Label 3)

The dataset seems suitable for a classification task where the machine learning model aims to predict the price range category of a mobile phone.

Tools Used: VS Code, Anaconda, AWS SageMaker, AWS S3, AWS IAM User, AWS IAM Role.

The project can be divided into three parts: Setup, Training and Development.

SETUP

Step 1: Installing AWS CLI to communicate better with Management Console from VS Code. Make sure to give the IAM User Administrative access. Download the access keys and keep them somewhere secure, avoid sharing it with anyone.

Step 2: Created a user with Administrator access so that interaction between user and local machine is seamless.

Step 3: Created a new environment in VSCode listing all the requirements in a text file. Packages included boto3, sagemaker, scikit-learn,pandas, numpy and ipykernel

Step 4: Set up an S3 bucket for storage of train and test files into the cloud.

TRAINING PHASE

The training phase was a series of steps followed, which included data ingestion, feature engineering, writing a script file to get the tasks done, creating an IAM Role and then performing the actual training.

Data ingestion

Sent the train and test files in S3 buckets.

Script.py

Wrote a script that used the Random Forest Classifier from sklearn.

%%writefile script.py was used to create a script in a notebook.

Creating an IAM Role

IAM Role(not user) was created and the ARN was used in the script. Made sure to add SageMaker policy in the role to prevent any errors further in the code.

Sagemaker using the Script.py file

The script.py file serves as the entry point for our sklearn model. Here the ARN of the role comes in play.

# Importing sagemaker's default SKLearn library
from sagemaker.sklearn.estimator import SKLearn

FRAMEWORK_VERSION = "0.23-1"

sklearn_estimator = SKLearn(
    entry_point="script.py",

    # ARN of a new sagemaker role (ARN of user does not work)
    role="arn:aws:iam::905418303768:role/sagemaker-role",

    # creates instance inside the Sagemaker machine
    instance_count=1,
    instance_type="ml.m5.large",

    # framework version present in the documentation, declared above
    framework_version=FRAMEWORK_VERSION,

    # name of folder after model has been trained
    base_job_name="RF-custom-sklearn",

    # hyperparameters to the RF classifier
    hyperparameters={
        "n_estimators": 100,
        "random_state": 0,
    },
    use_spot_instances = True,
    max_wait = 7200,
    max_run = 3600
)

Before deploying the model, methods such as .fit are used to ensure model training gets completed.

The Model accuracy on the testing data is 88.33%.

DEPLOYMENT PHASE

To ensure that a copy of the model is created , another location is specified. This step is taken as a measure to ensure availability so that the copy of the model is used for deployment.

End-point Deployment

This is done by performing the model.deploy() function

endpoint_name = "Custom-sklearn-model-" + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print("EndpointName={}".format(endpoint_name))

predictor = model.deploy(
    initial_instance_count=1,

    # deploy in this specific instance as an endpoint
    instance_type="ml.m4.xlarge",
    endpoint_name=endpoint_name,
)

Testing the deployment

A sample example was taken to test the deployment. Since it was a multi class classification problem, the solution was dependent on 20 dimensions. For a sample set of points, the classification for the mobile came out to be Very High Price Range.

| Feature         | Value |
|-----------------|-------|
| Battery Power   | 1454  |
| Bluetooth       | 1.0   |
| Clock Speed     | 0.5   |
| Dual SIM        | 1.0   |
| Front Camera    | 1.0   |
| 4G Support      | 0.0   |
| Internal Memory | 34.0  |
| Depth           | 0.7   |
| Weight          | 83.0  |
| Cores           | 4.0   |
| PC              | 3.0   |
| Pixel Height    | 250.0 |
| Pixel Width     | 1033.0|
| RAM             | 3419.0|
| Screen Height   | 7.0   |
| Screen Width    | 5.0   |
| Talk Time       | 5.0   |
| 3G Support      | 1.0   |
| Touch Screen    | 1.0   |
| WiFi            | 0.0   |

 ---------------------------------------------------------------------
| Price Range     | * MODEL DETERMINED AS 3 => VERY HIGH PRICE RANGE* |
 ---------------------------------------------------------------------

Learning Resources:

• Krish Naik’s tutorial
• Linkedin Learning on AWS Sagemaker

Links to Code and files: Github

GitHub - guneet-kohli/AWS-Sagemaker-Mobile-Price-Classification: Deployed a mobile price prediction model using scikit-learn on AWS SageMaker. Trained a Random Forest classifier for accurate predictions based on key features. Streamlined deployment with a concise guide and seamless integration of AWS services.

And here I am, after one week of continuously searching and solving dumps that I found online, clearing my first ever Microsoft Certification. After an entire week of rigorous training and focus. Azure Data Fundamentals validates foundational knowledge of core data concepts and how these concepts are implemented using Microsoft Azure data services, For doing preparation in a situation that is time-bound , one needs to perform a step-by-step analysis. A through understanding of the components required to ace the certification.

Day 1

(Monday, 29th August)

Firstly, I went through Microsoft Learn website to understand the components and skills required for clearing this certification. The percentage breakup of the skills measured was clearly mentioned on the website, the outcomes were as follows:

• Describing core data concepts (25-30%)
• Identifying considerations for relational data on Azure (20-25%)
• Describing considerations for working with non-relational data on Azure (15-20%)
• Describing an analytics workload on Azure (25-30%)

After gaining a through understanding of the syllabus, on the Microsoft Learn portal there was an entire section dedicated to these learning outcomes. Under each outcome 2 or 3 modules along with quizzes were present, which played a crucial role in helping me ace my certification. On Day 1, I thoroughly prepared fundamentals via Microsoft’s official learning platform.

Day 2

(Tuesday, 30th August)

With the advent of the second day, I revised the contents of the Udemy Course, “DP-900: Microsoft Azure Data Fundamentals in a Weekend” by in28minutes Official.

The course helped me gain knowledge about:

• Core Data concepts
• Working with relational data on Azure
• Working with non relational data on Azure
• Working with analytics workload on Azure.

Here’s the link to the Udemy course,

“https://www.udemy.com/share/1054Cw/”.

Day 3

(Wednesday, 31st August)

After going through five sections of the Udemy Course on second day, third day started with the target of achieving next six sections. The summarized notes and presentations shared by the instructor helped in recapitulating concepts learned on the second day. After completion of most of the coursework, I came through a YouTube video , shared by my friend who helped me practice and put my skills to a test. As the third day came to an end, I was done with 11 sections of Udemy courses and 20 Questions of Youtube video.

Day 4

(Thursday, 1st September)

This day was all about Practice, Practice and Practice. The more Practice I did, the more I felt the need to learn more about Azure. On this day, covered all the 80 questions in the video and curated some handmade notes to help me with a through understanding.

After being confident enough about preparation, in the evening we booked our exam. But due to harsh luck, no slot was available on the next day. Hence, I booked the slot for 3rd of September.

Day 5

(Friday, 2nd September)

On the fifth day, I decided to go for the mock test that came with Udemy course. The test was quite easy to crack and had a conceptual understanding of various topics. This test was enough to brush up my skills.

After doing and reverse engineering the contents of the mock test, I decided to take a break and relax for a while. However, while relaxing I forgot to keep an eye on my inbox and I got to know that after almost 24 hours of your booking, Microsoft shares an official mock test.

Day 6 — The exam day

(Saturday, 3rd September)

As I woke up on the exam day with the intent to relax, I came across the official mock test mail. I felt immediately the need to attempt it, and hence decided to go for it. Just to save some time, I modified the test and instead of attempting 40-45 questions at a time. I went for attempting all the 119 questions at a go, which actually turned out to be quite hectic. After attempting the questions, I felt apprehensive as I had just scored 59% and 70% was the cut off required to clear the exam. So, I got determined to review the questions which I got wrong. I decided to reschedule the test and prepare more for it, but unfortunately the exam was in the evening and for rescheduling the exam, you need to inform at least 24 hours prior to the exam. So, I was stuck in a situation which was similar to a swamp. To my rescue, came an idea to curate last minute handouts for revising before the exam. These last minute handouts helped me clear my exam.

At 5pm, I checked in for my exam and by 6.30pm I had cleared the certification and got my Badge of Azure Data Fundamentals. I felt elated at that moment. I hope my strategy will help you clear your DP-900 certification. GOOD LUCK!

Microsoft Certified: Azure Data Fundamentals was issued by Microsoft to Guneet Kohli.

Let’s start by creating a folder which’ll hold all the components needed to create this web app. From creating a virtual environment, .gitignore file to the final app.py file, everything will be stored in this dedicated directory.

This is how our dashboard will look like:

So, Let’s Begin

The first step of using Python language comes with “Downloading & Importing Libraries” 😃. Since, we are using libraries like Plotly and Dash, we need to ensure that these libraries are present in our virtual environment. All the libraries that were required during the creation of this Web App have been listed in requirements.txt file present in Github repository (link shared at the end). The steps to create a dedicated app directory and a virtual environment are:

cd <initial-folder> # The folder selected initially

mkdir dash_app_example # Creating a dedicated app directory.

cd dash_app_example #moving to the dedicated app directory.

virtualenv venv # Create the virtual environment ‘venv’.

venv\Scripts\activate #Activates the virtual environment on Windows

pip install <package-name> #Helps in installing packages

After making sure all the packages are installed, let us move to Jupyter Notebook and create a new notebook in the dedicated folder. I’m working on Jupyter notebook but you can work on any other text editor as well, be it Atom, VS Code or anything that works for you. But make sure that your file name is app.py

Dataset Used

The data repository for the 2019 Novel Coronavirus Visual Dashboard is operated by the Johns Hopkins University Center for Systems Science and Engineering (JHU CSSE). Also, Supported by ESRI Living Atlas Team and the Johns Hopkins University Applied Physics Lab (JHU APL).

Three different URLs were used for checking the cases: Confirmed, Recovered and Dead, which were all in csv format.

Data Cleaning

• Cleaning of data was performed country-wise in time-series format for country selected
• Overall case count for confirmed, recovered and dead cases was calculated by using a blocks of code.
• In this stage values for COVID-19 Case count were also evaluated.

Generating the line graph

After performing country and case wise data cleaning on the dataset provided. The User Interface development phase began with the first-and-foremost step of creating a line graph that would represent everyday data of COVID-19 Patients. The following code block represents both country-wise data processing and creation of a line graph

def fig_world_trend(cntry='US',window=3):
    df = process_data(data=covid_conf_ts,cntry=cntry,window=window)
    df.head(10)
    if window==1:
        yaxis_title = "Daily Cases" 
    else:
        yaxis_title = "Daily Cases ({}-days MA)".format(window)
    fig = px.line(df, y='Total', x=df.index, title='Daily confirmed cases trend for {}'.format(cntry),height=600,color_discrete_sequence =['indigo'])
    fig.update_layout(title_x=0.5,plot_bgcolor='#cfd7fa',paper_bgcolor='#ffffff',xaxis_title="Date",yaxis_title=yaxis_title)
    return fig

Dash Application

Most of the work in Dash is conceptually based on fundamental principles of Web Development. Basic understanding about HTML5, CSS and Javascript comes in handy while creating the UI. To create a secure dashboard, username and password pairs were generated, followed by creation of a dropdown list for every unique country.

def get_country_list():
    return covid_conf_ts['Country/Region'].unique()

def create_dropdown_list(cntry_list):
    dropdown_list = []
    for cntry in sorted(cntry_list):
        tmp_dict = {'label':cntry,'value':cntry}
        dropdown_list.append(tmp_dict)
    return dropdown_list

def get_country_dropdown(id):
    return html.Div([html.Label('Select Country'),
                        dcc.Dropdown(id='my-id'+str(id),
                            options=create_dropdown_list(get_country_list()),
                            value='US'
                        ),
                        html.Div(id='my-div'+str(id))
                    ])

Furthermore, features like Graph Container for Dash, Moving Window Slider were added before generating App Layout and assigning dash callbacks.

To run the Application on local host, the following command needs to be executed as it will share the Dash URL where the web application is deployed in the production environment.

app.run_server(host= '0.0.0.0',debug=False)

An Overview of the Application

The above You Tube video will give an overview of the application and its features. For instant access to code, link to my Github profile has also been shared.

Source Code

The repository is made available on Github at the following link:

COVID19/app1.ipynb at main · guneet-coder/COVID19

For any queries, kindly report in the issues section of my Github profile. Hope this helped you!

I started my internship with Cognizant Technology Solutions amidst mid January, 2022. My tenure as an intern at Cognizant was an out-of-the-world experience. From enhancing my persona to developing my technical skills, the exposure I got from Cognizant was the kickstart that every fresher in this rapidly growing IT sector demands. Indeed, it was with tons of hardwork and a stroke of luck that I got selected as an Intern in such a prestigious organisation. These six months flew by and here I’m sharing my amazing experience with this Multinational Corporation.

JANUARY

Week 1: (18th January- 21st January, 2022)

My first week at Cognizant was indeed a thrilling one, despite having a Work from Home internship, the level of interaction we had during our Teams meet was unparalleled. Interns from all over the country were present in the induction session, where various company policies were shared. Diversified sessions were held from time to time, focusing especially on interns’ mental wellness and heartfulness. These programs assisted us to connect with our inner-self & helped in decluttering one’s mind. A boot camp was also organised which focused on minimising waste, it was a simple series of steps delivered via an online pragmatic course for gaining knowledge, resources and guidance and it influenced us to drive change at personal level within our families and community.

Moreover, in this week vital topics to thrive in this corporate world were also discussed, which included Data Security, Code Of Ethics Acceptable Use and prevention of sexual harassment at the workplace.

Week 2: (24th January — 28th January, 2022)

My second week started off with Behavioural training sessions and Working remotely ethics. To succeed as an individual, training and tips especially related to growth mindset were held from time to time. Another big change that cognizant brought in my life was the introduction of Cognizant Health Challenge. Its perks included:

· Eight weeks of fun, health and fitness

· Exciting rewards and giveaways each week

· Personalised, AI-powered diet and fitness plan

· Engaging live webinars

In the words of the CEO — Brian Humphries, “You are working for a company with a big heart that cares deeply about you. Together, we’ve come through a two-year, COVID-induced humanitarian crisis that has also caused severe stress and fatigue.I would encourage all of you to pay close attention to your mental and emotional well-being as well as your physical health. The leadership team and I want you to know that your health and well-being take priority over absolutely everything else.”

FEBRUARY

Week 3: (31st January — 4th February, 2022)

First week of February began with a test, it was used to assess our reading, listening, grammar and speaking skills for ensuring that we are business ready. Apart from these tests, a series of well-being sessions were conducted from time to time in this epoch.

Week 5: (7th February — 11th February)

From the second week of February, our technical training started, it began with brushing up our skills to get industry ready with courses like: User Interface Programming (HTML 5, CSS 3 & JavaScript), Database Programming using ANSI SQL. This week was dedicated to SQL Learning specifically.

Week 6: (13th February- 18th February)

With almost over a month and a half in the company, working in the corporate sector had me in exponentially growing my learning curve. The main focus of this week was learning about Responsive Web Design, and connecting SQL with Java Databases.

Week 7: (21st February- 25th February)

This week was allotted to us as a buffer week to complete any backlogs that are left. So, most of the sessions in this week were Outreach.

MARCH

Week 8: (28th February- 4th March)

As we ushered into March, the celebration of International Women’s Day (IWD) in the coming week encouraged us to take advantage of Women Empowered (WE)-sponsored events that shared women’s contributions across Cognizant, the importance of male ally-ship, mentorship opportunities, and ways you can help “Break the Bias.” Participation of Women in Technology was highly encouraged especially to #BreakTheBias.

Week 9: (7th March — 11th March)

After getting trained on a vast range of technology, this week began with assignment of a domain. The technology allotted to me was Data Engineering with Azure.

Week wise plan was allocated to us and it resulted in completing Python for Beginners: Learning Python Programming.

Week wise plan was allocated to us and it resulted in completing Python for Beginners: Learning Python Programming.

Week 10: (14th March — 18th March)

With the advent of the tenth week, multiple Python courses started in parallel, Python for Programmers and Python Bible along with a hands-on of around 100 problems in Python.

Week 11: (21st March — 25th March)

The week was flooded with knowledge, from learning to do visualizations using python libraries to creating dashboards. It was a fun filled week with completion of courses, these were Python Enablement, Data Analysis, Complete Courses on Data Visualization, Matplotlib and SQL, with a deadline to complete the courses by the end of this week.

Week 12: (28th March — 1st April)

This week focused on data bricks and its various aspects. Introductory Knowledge about Spark was an enlightening experience. Another test for English proficiency was held by EFSET for ensuring our business communication skills are upto the mark.

APRIL

Week 13: (4th April- 8th April)

After performing miscellaneous self-learning tasks, a Python trainer was allocated. Most of the sessions conducted during this period were Doubt sessions. Over the course of April start, everyday assignments and sessions were held which helped in grasping most of the concepts in a pragmatic learning approach. Attached are the snippets of all the assignments.

Week 14: (11th April — 15th April)

Week 14th consisted of Python Doubt sessions with assignments. The snapshots of assignments are attached alongside. Concepts like exception handling, file handling, working with libraries, etc were practised frequently and helped in building a strong fundamental knowledge about Python Programming.

Week 15: (18th April — 22nd April)

Over the course of these three weeks, we were required to acquire knowledge of Programming with Databricks. Since, Apache Spark has lately conquered the big data world, so special emphasis was given on grasping concepts of today’s “Big-Data King” platform.

Week 16: (25th April- 29th April)

In this week, a programming test for SQL was scheduled. The test focussed most on SQL Joins and also considered our knowledge whilst applying queries and a few concepts of normalization were covered — namely 1st Normal Form — . Furthermore, rest of the week was focused on practicing SQL hands-on problems on hacker rank.

Week 17: (25th April- 29th April)

As this week started, along with Daily Connect meets, Started BH- sessions. These sessions were usually for understanding the corporate culture. Along with these sessions went on Python Classes which became more interactive and became a source of learning.

MAY

Week 18: (2nd May- 6th May)

In this week, we were assigned with a case study, for evaluating our skills in a business unit. The case study was about creating a Python based Web App for checking the analysis of COVID patients all around the world. Here within, I have attached my GitHub link of the implementation. Looking forward to write a blog about that as well :p . Make sure to star and follow me on Github as well.

GitHub - guneet-coder/COVID19: Dashboard/ Web App

Week 19: (9th May -13th May)

This week started with Azure Training. From learning concepts of cloud computing i.e., creating a virtual machine, resource group,learning about datacenters, policies, tags, Azure SQL, Dynamic Data Masking, etc.

Week 20: (16th May- 20th May)

In week 20, major tasks allocated included creating a blob storage and understanding the differences between blob storage and datalake. In the diagrams “maysa” is a blob storage and “ADFmay2022” is a data factory created as a sample.

Week 21: (23rd May- 27th May)

As week 21 started, the creation of pipelines in Azure Data Factory started. Here is a summary of a pipeline in Data factory which copies data from Azure Bob Storage to another Blob Storage.

Week 22: (30th May- 3rd June)

This week was allotted for completion of self-learning tasks and Udemy courses, especially for preparing for Microsoft certifications like DP-900 and DP-100.

JUNE

Week 23: (6th June-10th June)

With the advent of 23rd week, concepts such as :

· Parameterized pipeline,

· ARM template,

· Automation,

· Triggers,

· Datalake,

· Self-hosted ADF, etc were covered.

Week 24: (13th June-17th June)

In the final week of my internship, most of the focus was on covering Udemy course concepts and pragmatic learning, Data Engineering DP-203 by Microsoft. Conceptual clarity and implementation, specific to Azure Data Factory was covered. Our target was to create pipelines that helped in efficiently managing and transforming data so that assorted and unstructured data files become business-ready.

As my internship experience comes to an end, I’m highly grateful for getting this experience. Through the cycles of ups and downs, I have almost completed this internship. It’s a huge milestone for me in this world of technology, with many other paths to explore. I’m indebted to my family and friends who went with me through this Work from home phase as it wasn’t really easy. Also, I would like to thank Sachin Bagga sir, my college professor who boosted my morale in these tough times and asked me to stay in high spirits. Looking forward to a this portal that has opened a world of opportunites for me as a Data Engineer, hopefully…🤞😃

Amidst the lockdown, when all our hopes were stranded, I was encouraged by my professor, Dr. Sumeet Kaur Sehra to set up a platform for all the tech enthusiasts, specifically for the upcoming Data Scientists of our college who’ll rule the industry, I sincerely hope. This erudite journey has been an extremely enriching experience for me. I learnt about the inside out of how to become an entrepreneur along with brushing up my technical skills. When Sehra ma’am asked me to set up the club, I was highly elated as I thought what is a better opportunity for giving back to society than sharing knowledge.

What was the need to bring together a new group?

The purpose of the club was to bring together a group who’d like to contribute and work in the field of Data Science at Guru Nanak Dev Engineering College, Ludhiana. The first few months of setting up the club were quite exhaustive as it was almost impossible to gather students. It was a time consuming process, but once a panel was formed the learning curve has shown a good fit. The club hasn’t stopped ever since.

Since the club was set up amidst the lockdown, most of the communication was through social media. From Instagram page to creating our own website for the club by its members, the club proved to be a source of motivation for many students, who’d love to kick start their journey of being a Data Scientist.

What inspired students to join the club?

Let’s actually hear these amazing students who joined the club and what was their motivating factor and how they landed commanding positions

I am really grateful to be part of such an amazing and inspiring community. I hope to see the value this club brings to my juniors along the line. This was a beautiful chapter in my college life, I aspire that this platform brings out the best in all the academicians who wish to be a part of this tech team :)

The hiring process had 5 rounds, each round being an elimination round. The eligibility criteria for appearing in the selection process was as follows:
• Applicable to diverse candidates from 2022 graduation batch with no active
backlog & CGPA>6/10 or %>60% through out.
• Eligible Courses — B.E/B.Tech, MTech, MCA, Integrated Course.

ROUND 1

The first round comprised a technical aptitude test which had MCQs from a variety of topics like OS, DBMS, SQL, Software Engineering, etc It was held on the EduThrill platform. The technical aptitude test duration was 30 minutes I gave the first test on 9th November, 2021. The results were announced through email within an hour of submitting the first test.

ROUND 2

It was a coding round and the time allotted was 60 minutes. The second test was held on 9th November in the latter part of the day. I received the email from Accolite Digital on 14th November that I had cleared the second round of assessment as well. Due to high number of applicants, my next round was scheduled after almost a month — on 10th December.

ROUND 3

I was quite nervous before the third round. Before entering the meeting, I closed my eyes and took a deep breath, and I think that is what helped me in clearing my third round. This round was a live coding round, it had a panel of interviewers who were all watching me code the solution to the problem statement. Being really tired from all the college classes, I got stuck in the coding part of a question(here comes the best part) but the interviewer guided me and eventually I solved the question.(I really felt proud of myself at that moment, Thank you sir for your guidance).

ROUND 4

This was the final technical round, it was similar to the third round. The only difference was that the coding questions were tougher this time. It was again a mix of coding questions and technical interview. The discussion lasted for more than an hour. I solved the questions and even answered the questions, which were related to software engineering — like the SDLC models(Waterfall Model, Spiral Model, etc.).The final technical round, i.e. the fourth round was held on 15th December.

ROUND 5

This was the HR round. In this round, most of the questions regarding joining, work culture, etc were answered by their team. It was an exhaustive discussion. Each and everything was explained very well.

After the round 5, they shared the employment offer via the email. Accolite Digital was also offering an internship along with full time job offer. The whole process was a great learning experience for me. I didn’t accept the employment offer due to some personal reasons. But, I really liked the interview experience.

The best part about this interview was that Accolite was that they even invited me to their Virtual Christmas concert😍. I think they really believe in Michelle Kwan’s quote, “Work Hard, Be Yourself and Have Fun!”

That was my experience interviewing with Accolite Digital. I hope it helped you and answered any questions that you had in your mind. 😄

Wishing you luck!

A blockchain is nothing but a chain of blocks(generally records), as the name suggests. Not how you are imagining pictorially, but it is a P2P network used to store records whose main purpose is to maintain system integrity by eliminating all kinds counterfeiting techniques. From a Peer-to-Peer Network (P2P) one can understand that all the users have the same powers and all the transactions done are visible at all stages, thus eliminating the need of a central authority.

Blockchain technology is the essence of cryptocurrency, which is nothing but a collection of data which is designed to work as a medium of exchange. These digital assets are the foundation of today’s capital and tomorrow’s finances. Thus, the need to understand how this technology works is quite relevant.

How transactions take place in a blockchain?

Blockchain uses the concept of hashing, the purpose of which is to encrypt the details so that a hacker is not able to read or alter the data. Hash is similar to a person’s fingerprint, except that these change every time a change is made in the block so that the integrity is maintained.

Let’s consider a scenario:

Suppose Chandler and Pheobe want to send Joey 5 Bitcoins.

Transaction t1: Chandler → Joey

Transaction t2: Pheobe → Joey

For a transaction to take place, a block needs to be created. The transaction details are permanently inscribed in this block. Since it is a decentralized network, so the changes made are visible to all users in the network, which makes it difficult to hack. Here two transactions are taking place, hence two different blocks will be generated. These consecutive blocks are tied up, hence the alias “chain” , forming a public distributed ledger. Hence this ledger is available to Chandler, Pheobe and Joey.

The block contains the transaction details, hash of the current block and hash of the previous block. The blocks are connected via hash to the previous block.

Whenever a transaction is made, or a change is done, the hash gets altered, thereby breaking the chain for a small duration. The process of verification happens during that time, it is technically termed as, “Proof Of Work”. After the verification is done, the hash value gets updated and the connection between the blocks is made.

Who can perform this validation?

Such transactions are made all over the globe, the people who validate these transactions are known as miners. For a block to be validated and added to the chain, miners need to solve a complex mathematical problem. The one who solves that problem quickest gets 12.5 Bitcoins, as a reward. This process is known as mining.

Like, many of you may remember the show, “The Big Bang Theory” how the guys forgot about the bitcoins they mined seven years ago, when they were not even worth a penny. Years later, they wish they could have learnt the value of cryptocurrency back then.

Understanding the concept of keys

Every user in a blockchain has two types of keys. One of them is a private key, which is confidential and the other one is a public key, which is visible to the world.

Let’s suppose that the guys would have been successful in getting back some Bitcoins . Assuming, Leonard wants to make a transaction of 1 BTC to Penny.

Transaction: Leonard → Penny

For making this transaction, Leonard sends his and Penny’s wallet address through an hashing algorithm, these details are encrypted using encryption algorithms and Leonard’s private key, which ensures that the transaction was done by Leonard. This is now transmitted across the world, using Penny’s public key. She can now decrypt the message by using her own, i.e. Penny’s private key, which only she knows.

Thus, the need of the hour is to ensure transparency in the digital era. Blockchain will help in maintaining integrity and making sure that unethical practices are kept at bay.

Elements Of Google Cloud: GCP has various elements like Compute Engine, Google Cloud App Engine, Google Cloud Container Engine, Google Cloud Storage, Google Cloud Dataflow, Google BigQuery, Google Cloud Machine Learning Engine, etc. Each element has its own unique purpose. For instance, Google BigQuery can be used for analysis providing the user with SQL workplace as well as for the Administration part, which provides facilities like Monitoring, BI Engine, etc.

For creating a Virtual Machine, Cloud Engine under the Navigation Menu will be employed. Compute Engine is an IaaS service which provides user to work with virtual instances for workload hosting.

Steps for creation of a Virtual Machine

1. Under the Navigation Menu, select Compute Engine and then click on VM instances.

2. Under the dropdown menu, click CREATE INSTANCE for creating a new instance and create a new VM instance by configuring various parameters, like Machine configuration, Bootdisk, Identity and API access along with firewalls.

3. Click CREATE. It will take a minute for the machine to be created. To check, if the machine is created successfully, check the VM instances page. The green mark against the status shows that the VM instance was succesfully created.

4. SSH(Secure Shell) also known as Secure Socket Shell, is a network protocol that gives users, particularly system administrators, a secure way to access a computer over an unsecured network.It is used to connect to virtual machine, in the row for your machine. To do this, click on SSH. Then a pop-up would appear which will ask the user if they want to initiate SSH connection.

5. After successfully connecting, SSH keys will be transferred to the VM and our VM, here Debian GNU/Linux is created.

CREATING A NEW INSTANCE USING COMMAND PROMPT

Instead of using the Cloud Console to create a virtual machine instance, one can use the command line tool, “gcloud”.

Command used for creation of VM instance,

“gcloud compute instances create <new-instance> — machine-type <machine-details> — zone <zone-name>”

THE NEW INSTANCE, GUNEET-KOHLI2 HAS THESE DEFAULT VALUES:

•The latest Debian 10 (buster) image.

•The n1-standard-2 machine type

• A root persistent disk with the same name as the instance; the disk is automatically attached to the instance.

SSH is used to connect this newly created instance using via gcloud. The command used is,” gcloud compute ssh <new-instance> — zone <zone-name>”

After connecting to SSH, public/ private rsa key pair will be generated, and instance details will be presented.

To check, if the new instance was created successfully, go to the VM instances page, and check if the instances you created are present.

After creation of virtual machine, one can map existing server infrastructure, host a web page, create load balancers, network topology and what not to GCP.

The ascendancy of Virtualization and the indispensable need of creation of VMs, to optimize Quicker Desktop Provisioning and deployment. This technology is not only cost-effective, but it also assists the environment by reducing carbon footprint, because of its ability to cut down on number of servers and addressing ones needs logically rather than physically.