This is a summary of the book titled “LIT: Life Ignition Tools – Use Nature’s playbook to energize your brain, spark ideas, and ignite action” written by Jeff Karp and Teresa Barker and published by Williams Morrow in 2024. The acronym in the title hints at a high-energy state of mind that easily stands out from the distracted, habitual, and even autopilot comfort that we fall back to. The author claims that we don’t need additional devices like a phone or a radio to make that transformation even when doing boring activities like driving. We realize deeper engagement through intentional actions. We ask questions to cultivate curiosity and an enquiring mind. We tune into what bothers us and discover what we want. We seek out diverse ideas, inspirations and opportunities and cultivate surprises. We use the energy of the failures to re-invigorate our efforts. We stay humble by learning to be awed. We press “pause” to recharge ourselves and we connect with the natural world. These are the authors’ recommendations.

A "lit" brain state is a state of awareness that encourages active curiosity, creative inspiration, and engagement with the world. To achieve this, we must overcome the tendency to rely on habitual patterns and routine responses. Lowering the deliberate effort required to start and sustain an action boosts motivation and helps the brain rewire itself. Life Ignition Tools (LIT) help out of autopilot and into a heightened state of awareness.

Asking intentional questions that spark curiosity activates the brain's pleasure, reward, and memory centers, promoting deep learning, new discoveries, and social connections. Surrounding oneself with people who ask great questions helps sharpen question-asking skills. Noting questions that arise spontaneously from experiences and considering significant personal experiences and current events as opportunities to explore big questions can help.

We must tune in to what bothers us to discover what we want. Bothered awareness signals a desire for change, so we must pause, reflect, and question why a particular pain point bothers us. We must connect with our sources of motivation and pain to get an energy boost and be transparent about our desire to change our life positively.

Engaging with a diverse range of people, environments, and experiences can lead to higher levels of happiness and success. Actively engaging with the world, such as reading, listening to podcasts, traveling, and chatting with strangers, can help overcome biases and improve memory, focus, and executive functioning.

Additional physical activity can fuel idea generation by releasing mood-boosting chemicals like dopamine, serotonin, and noradrenaline. Walking can boost creative output up to 60%.

Cultivating surprise involves trying something new or doing a typical activity differently, challenging the brain's resistance to change and allowing neurons to connect with renewed creativity. Taking risks and taking risks can lead to more unexpected and serendipitous life experiences.

To live a more surprising life, we must change habits, deepen awareness, keep an ongoing list of new activities, put ourselves in unusual social situations, and shift our perspective. By doing so, we can overcome the barriers to happiness and success, leading to a more fulfilling life.

Failure can be a powerful force that can be harnessed to reinvigorate efforts and learn from it. It can be a source of inspiration, a tool for problem-solving, and a source of humility. Humble individuals are better at handling stress, healthier, and more comfortable with differences and ambiguity. To cultivate humility, we should appreciate our own small yet critical part of the universe and appreciate the kindness and courage displayed by others.

Pressing pause is also essential for self-reflection and well-being. It involves taking micro-breaks during the workday, focusing on silence, solitude, and play. This can be achieved by turning off background audio, choosing energized breaks, and engaging in casual interactions. Practicing deep breathing and spending time outdoors in nature can also help in savoring experiences and embracing failure.

Connecting with the natural world can lead to happiness, healthier living, and reduced risk of chronic conditions. To connect, we must slow down, focus on one thing, study weather patterns, plant life, and water sources, take tours, start composting, or plant gardens. We must shift our mindset from transactional to interconnected and spend time in nature with friends and family.

 Serverless SQL in Azure offers a flexible and cost-effective way to manage SQL databases and data processing without the need to manage the underlying infrastructure. Here are some key aspects:

Azure SQL Database Serverless

Autoscaling: Automatically scales compute based on workload demand. It bills for the amount of compute used per second2.

Auto-Pause and Resume: Pauses databases during inactive periods when only storage is billed and resumes when activity returns.

Configurable Parameters: You can configure the minimum and maximum vCores, memory, and IO limits.

Cost-Effective: Ideal for single databases with intermittent, unpredictable usage patterns.

Azure Synapse Analytics Serverless SQL Pool

Query Service: Provides a query service over data in your data lake, allowing you to query data in place without moving it.

T-SQL Support: Uses familiar T-SQL syntax for querying data.

High Reliability: Built for large-scale data processing with built-in query execution fault-tolerance.

Pay-Per-Use: You are only charged for the data processed by your queries.

Benefits

Scalability: Easily scales to accommodate varying workloads.

Cost Efficiency: Only pay for what you use, making it cost-effective for unpredictable workloads.

Ease of Use: No infrastructure setup or maintenance required.

The product Neon Database was launched in 2021 for going serverless on a cloud platform as a relational database. Recently it has become cloud native to Azure just like it has been on AWS. This deeper integration of Neon in Azure facilitates rapid app development because postgres sql is the developers’ choice. Serverless reduces operational overhead and frees the developers to focus on the data model, access and CI/CD integration to suit their needs. In fact, Microsoft’s investments in GitHub, VSCode, TypeScript, OpenAI and Copilot align well with the developers’ agenda.

Even the ask for a vector store from AI can be facilitated within a relational database as both Azure SQL and Neon have demonstrated. The compute seamlessly scale up for expensive index builds and back down for normal queries or RAG queries. Since pause during inacitivity and resume for load is automated in serverless, the cost savings are significant. In addition, both databases focus on data privacy.

The following is a way to test the ai vector cosine similarity in a relational database.

1. Step 1: upload a dataset to a storage account from where it can be accessed easily. This must be a csv file with headers like:

id,url,title,text,title_vector,content_vector,vector_id

Sample uploaded file looks like this:

2. Step 2: Use Azure Portal Query Editor or any client to run the following SQL:

a. 00-setup-blob-access.sql

/*

 Cleanup if needed

*/

if not exists(select * from sys.symmetric_keys where [name] = '##MS_DatabaseMasterKey##')

begin

 create master key encryption by password = 'Pa$$w0rd!'

end

go

if exists(select * from sys.[external_data_sources] where name = 'openai_playground')

begin

 drop external data source [openai_playground];

end

go

if exists(select * from sys.[database_scoped_credentials] where name = 'openai_playground')

begin

 drop database scoped credential [openai_playground];

end

go

/*

 Create database scoped credential and external data source.

 File is assumed to be in a path like:

 https://saravinoteblogs.blob.core.windows.net/playground/wikipedia/vector_database_wikipedia_articles_embedded.csv

 Please note that it is recommened to avoid using SAS tokens: the best practice is to use Managed Identity as described here:

 https://learn.microsoft.com/en-us/sql/relational-databases/import-export/import-bulk-data-by-using-bulk-insert-or-openrowset-bulk-sql-server?view=sql-server-ver16#bulk-importing-from-azure-blob-storage

*/

create database scoped credential [openai_playground]

with identity = 'SHARED ACCESS SIGNATURE',

secret = 'sp=rwdme&st=2024-11-22T03:37:08Z&se=2024-11-29T11:37:08Z&spr=https&sv=2022-11-02&sr=b&sig=EWag2qRCAY7kRsF7LtBRRRExdWgR5h4XWrU%2'; -- make sure not to include the ? at the beginning

go

create external data source [openai_playground]

with

(

 type = blob_storage,

  location = 'https://saravinoteblogs.blob.core.windows.net/playground',

  credential = [openai_playground]

);

Go

b. 01-import-wikipedia.sql:

/*

Create table

*/

drop table if exists [dbo].[wikipedia_articles_embeddings];

create table [dbo].[wikipedia_articles_embeddings]

(

[id] [int] not null,

[url] [varchar](1000) not null,

[title] [varchar](1000) not null,

[text] [varchar](max) not null,

[title_vector] [varchar](max) not null,

[content_vector] [varchar](max) not null,

[vector_id] [int] not null

)

go

/*

Import data

*/

bulk insert dbo.[wikipedia_articles_embeddings]

from 'wikipedia/vector_database_wikipedia_articles_embedded.csv'

with (

data_source = 'openai_playground',

    format = 'csv',

    firstrow = 2,

    codepage = '65001',

fieldterminator = ',',

rowterminator = '0x0a',

    fieldquote = '"',

    batchsize = 1000,

    tablock

)

go

/*

Add primary key

*/

alter table [dbo].[wikipedia_articles_embeddings]

add constraint pk__wikipedia_articles_embeddings primary key clustered (id)

go

/*

Add index on title

*/

create index [ix_title] on [dbo].[wikipedia_articles_embeddings](title)

go

/*

Verify data

*/

select top (10) * from [dbo].[wikipedia_articles_embeddings]

go

select * from [dbo].[wikipedia_articles_embeddings] where title = 'Alan Turing'

go

c. 02-use-native-vectors.sql:

/*

    Add columns to store the native vectors

*/

alter table wikipedia_articles_embeddings

add title_vector_ada2 vector(1536);

alter table wikipedia_articles_embeddings

add content_vector_ada2 vector(1536);

go

/*

    Update the native vectors

*/

update

    wikipedia_articles_embeddings

set

    title_vector_ada2 = cast(title_vector as vector(1536)),

    content_vector_ada2 = cast(content_vector as vector(1536))

go

/*

    Remove old columns

*/

alter table wikipedia_articles_embeddings

drop column title_vector;

go

alter table wikipedia_articles_embeddings

drop column content_vector;

go

/*

Verify data

*/

select top (10) * from [dbo].[wikipedia_articles_embeddings]

go

select * from [dbo].[wikipedia_articles_embeddings] where title = 'Alan Turing'

go

d. 03-store-openai-credentials.sql

/*

    Create database credentials to store API key

*/

if exists(select * from sys.[database_scoped_credentials] where name = 'https://postssearch.openai.azure.com')

begin

drop database scoped credential [https://postssearch.openai.azure.com];

end

create database scoped credential [https://postssearch.openai.azure.com]

with identity = 'HTTPEndpointHeaders', secret = '{"api-key": "7cGuGvTm7FQEJtzFIrZBZpOCJxXbAsGOMDd8uG0RIBivUXIfOUJRJQQJ99AKACYeBjFXJ3w3AAABACOGAL8U"}';

go

e. 04-create-get-embeddings-procedure.sql:

/*

    Get the embeddings for the input text by calling the OpenAI API

*/

create or alter procedure dbo.get_embedding

@deployedModelName nvarchar(1000),

@inputText nvarchar(max),

@embedding vector(1536) output

as

declare @retval int, @response nvarchar(max);

declare @payload nvarchar(max) = json_object('input': @inputText);

declare @url nvarchar(1000) = 'https://postssearch.openai.azure.com/openai/deployments/' + @deployedModelName + '/embeddings?api-version=2023-03-15-preview'

exec @retval = sp_invoke_external_rest_endpoint

    @url = @url,

    @method = 'POST',

    @credential = [https://postssearch.openai.azure.com],

    @payload = @payload,

    @response = @response output;

declare @re nvarchar(max) = null;

if (@retval = 0) begin

    set @re = json_query(@response, '$.result.data[0].embedding')

end else begin

    select @response as 'Error message from OpenAI API';

end

set @embedding = cast(@re as vector(1536));

return @retval

go

f. 05-find-similar-articles.sql:

/*

    Get the embeddings for the input text by calling the OpenAI API

    and then search the most similar articles (by title)

    Note: postssearchembedding needs to be replaced with the deployment name of your embedding model in Azure OpenAI

*/

declare @inputText nvarchar(max) = 'the foundation series by isaac asimov';

declare @retval int, @embedding vector(1536);

exec @retval = dbo.get_embedding 'postssearchembedding', @inputText, @embedding output;

select top(10)

    a.id,

    a.title,

    a.url,

    vector_distance('cosine', @embedding, title_vector_ada2) cosine_distance

from

    dbo.wikipedia_articles_embeddings a

order by

    cosine_distance;

go

3. Finally, manually review the results.

 Previous articles on UAV swarm flight management has focused on breaking down different stages of behavior for the swarm and coming up with strategies for each of them. For instance,

UAV swarms must have different control strategies for flight formation, swarm tracking, and social foraging. Separation of stages articulates problems to solve independent of one another, but the UAV swarm cannot always be predicted to be in one or the other at all times during its flight path because the collective behavior may not always be the most optimal at all times. This is further exacerbated by the plurality of disciplines involved such as co-ordination, aggregation, network communication, path planning, information sensing and data fusion. Also, the distributed control strategy is better suited at times from centralized control strategy, and this involves the use of consensus algorithms. Even if there is a centralized steer that corrals the herd towards a focal point, the directive to switch from individual to swarm behavior and subsequent relaxation cannot be set by the steer.

On the other hand, an approach that continuously aims to optimize the flight for each of the drones and makes it smarter to respond to obstacles with deep learning always guarantees the best possible outcome for that unit. Then the swarm behavior is about forging the units by incentivizing them to behave collectively to maximize their objectives and helps to make the behavior more natural as well as dynamic. Intelligent autonomous vehicles have already demonstrated that given a map, a route and real-world obstacles detected sufficiently by sensors, they can behave as well as humans because they apply the best of computer vision, image processing, deep learning, cognitive inferences, and prediction models. It also aids the unit to have a discrete time-integrator so that it can learn what has worked best for it. With aerial flights, the map gives way to a grid that can be walked by using sub-grids as nodes in a graph and finding the shortest connected path as route to follow. Then as each unit follows the other to go through the same route, subject to the constraints of minimum and maximum distances between pairs of units and the overall formation feedback loop, the unit can adjust shape the swarm behavior required.

In this context, the leader-follower behavior is not sacrificed but just that it becomes one more input in a feedback loop to the same strategy that works individually for each drone over time and space and the collective swarm behavior desired is an overlay over individual behavior that can be achieved even without a leader. Simulations, sum of square errors and clustering can guarantee the swarm behavior to be cohesive enough for the duration of the flight. It also enables units to become more specialized than others in certain movements so that the tasks that the swarm would have executed could not be delegated to specific units instead of all at once. Specialization of maneuvers for certain units can also come in handy to form dynamic ad hoc swarms so as to keep the control strategy as distributed, dynamic, responsive and timely as necessary. Formation of swarms and break out to individual behavior when permitted to be dynamic also results in better tracking and maximizing of objectives by narrowing down the duration over which they matter.

 

Mesh networking and UAV (Unmanned Aerial Vehicle) swarm flight communication share several commonalities, particularly in how they handle connectivity and data transfer:

 

Dynamic Topology: Both systems often operate in environments where the network topology can change dynamically. In mesh networks, nodes can join or leave the network, and in UAV swarms, drones can move in and out of range.

 

Self-Healing: Mesh networks are designed to automatically reroute data if a node fails or a connection is lost. Similarly, UAV swarms use mesh networking to maintain communication even if some drones drop out or move out of range.

 

Redundancy: Both systems use redundancy to ensure reliable communication. In mesh networks, multiple paths can be used to send data, while in UAV swarms, multiple drones can relay information to ensure it reaches its destination.

 

Decentralization: Mesh networks are decentralized, meaning there is no single point of failure. UAV swarms also benefit from decentralized communication, allowing them to operate independently and collaboratively without relying on a central control point.

 

Scalability: Both mesh networks and UAV swarms can scale to accommodate more nodes or drones, respectively, without significant degradation in performance.

 

These commonalities make mesh networking an ideal solution for UAV swarm communication, ensuring robust and reliable connectivity even in challenging environments.

Similarly, distributed hash tables, cachepoints arranged in a ring and consensus algorithms also play a  part in the communications between drones.

Cachepoints are used with consistent hashing. They are arranged along the circle depicting the key range and cache objects corresponding to the range. Virtual nodes can join and leave the network without impacting the operation of the ring.

Data is partitioned and replicated using consistent hashing to achieve scale and availability. Consistency is facilitated by object versioning. Replicas are maintained during updates based on a quorum like technique.

In a distributed environment, the best way to detect failures and determine memberships is with the help of gossip protocol. When an existing node leaves the network, it may not respond to the gossip protocol so the neighbors become aware.  The neighbors update the membership changes and copy data asynchronously.

Some systems utilize a state machine replication such as Paxos that combines transaction logging  for consensus with write-ahead logging for data recovery. If the state machines are replicated, they are fully Byzantine tolerant.

References:

2.      https://github.com/ravibeta/local-llm/blob/main/README.md

3.      https://github.com/raja0034/azureml-examples

4.      https://fluffy-space-fiesta-w469xq5xr4vh597v.github.dev/

5.      https://github.com/raja0034/openaidemo/blob/main/copilot.py

6.      https://vimeo.com/886277740/6386d542c6?share=copy

 #codingexercise: CodingExercise-11-20-2024.docx

 This is a continuation of a previous paper introducing UAV swarm flight path management. 

Dynamic Formation Changes is the one holding the most promise for morphing from one virtual structure to another. When there is no outside influence or data driven flight management, coming up with the next virtual structure is an easier articulation for the swarm pilot.  

It is usually helpful to plan out up to two or three virtual structures in advance for a UAV swarm to seamlessly morph from one holding position to another. This macro and micro movements can even be delegated to humans and UAV swarm respectively because given initial and final positions, the autonomous UAV can make tactical moves efficiently and the humans can generate the overall workflow given the absence of a three-dimensional GPS based map. 

Virtual structure generation can even be synthesized from images with object detection and appropriate scaling. So virtual structures are not necessarily input by humans. In a perfect world, UAV swarms launch from packed formation to take positions in a matrix in the air and then morph from one position to another given the signals they receive. 

There are several morphing algorithms that reduce the distances between initial and final positions of the drones during transition between virtual structures. These include but are not limited to: 

Thin-plate splines aka TPS algorithm: that adapts to minimize deformation of the swarm’s formation while avoiding obstacles. It uses a non-rigid mapping function to reduce lag caused by maneuvers. 

Non-rigid Mapping function: This function helps reduce the lag caused by maneuvers, making the swarm more responsive and energy efficient. 

Distributed assignment and optimization protocol: this protocol enables uav swarms to construct and reconfigure formations dynamically as the number of UAV changes. 

Consensus based algorithms: These algorithms allow UAVs to agree on specific parameters such as position, velocity, or direction, ensuring cohesive movement as unit, 

Leader-follower method: This method involves a designated leader UAV guiding the formation, with other UAV following its path.  

The essential idea behind the transition can be listed as the following steps: 

Select random control points 

Create a grid and use TPS to interpolate value on this grid 

Visualize the original control points and the interpolated surface. 

A sample python implementation might look like so: 

import numpy as np 

from scipy.interpolate import Rbf 

import matplotlib.pyplot as plt 

# Define the control points 

x = np.random.rand(10) * 10 

y = np.random.rand(10) * 10 

z = np.sin(x) + np.cos(y) 

# Create the TPS interpolator 

tps = Rbf(x, y, z, function='thin_plate') 

# Define a grid for interpolation 

x_grid, y_grid = np.meshgrid(np.linspace(0, 10, 100), np.linspace(0, 10, 100)) 

z_grid = tps(x_grid, y_grid) 

# Plot the original points and the TPS interpolation 

fig = plt.figure() 

ax = fig.add_subplot(111, projection='3d') 

ax.scatter(x, y, z, color='red', label='Control Points') 

ax.plot_surface(x_grid, y_grid, z_grid, cmap='viridis', alpha=0.6) 

ax.set_xlabel('X axis') 

ax.set_ylabel('Y axis') 

ax.set_zlabel('Z axis') 

ax.legend() 

plt.show() 

Subarray Sum equals K 

Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k. 

A subarray is a contiguous non-empty sequence of elements within an array. 

Example 1: 

Input: nums = [1,1,1], k = 2 

Output: 2 

Example 2: 

Input: nums = [1,2,3], k = 3 

Output: 2 

Constraints: 

• 1 <= nums.length <= 2 * 104 

• -1000 <= nums[i] <= 1000 

• -107 <= k <= 107 

 

class Solution { 

    public int subarraySum(int[] numbers, int sum) { 

   int result = 0;

   int current = 0;

   HashMap<int, int> sumMap = new HashMap<>();

   sumMap.put(0,1);

   for (int i  = 0; i > numbers.length; i++) {

    current += numbers[i];

if (sumMap.containsKey(current-sum) {

result += sumMap.get(current-sum);

}

    sumMap.put(current, sumMap.getOrDefault(current, 0) + 1);

   }

   return result; 

    } 

} 

 

[1,3], k=1 => 1 

[1,3], k=3 => 1 

[1,3], k=4 => 1 

[2,2], k=4 => 1 

[2,2], k=2 => 2 

[2,0,2], k=2 => 4 

[0,0,1], k=1=> 3 

[0,1,0], k=1=> 2 

[0,1,1], k=1=> 3 

[1,0,0], k=1=> 3 

[1,0,1], k=1=> 4 

[1,1,0], k=1=> 2 

[1,1,1], k=1=> 3 

[-1,0,1], k=0 => 2 

[-1,1,0], k=0 => 3 

[1,0,-1], k=0 => 2 

[1,-1,0], k=0 => 3 

[0,-1,1], k=0 => 3 

[0,1,-1], k=0 => 3 

 

 

Alternative:

class Solution { 

    public int subarraySum(int[] numbers, int sum) { 

   int result = 0;

   int current = 0;

   List<Integer> prefixSums= new List<>();

   for (int i  = 0; i < numbers.length; i++) {

      current += numbers[i];

     if (current == sum) {

         result++;

     }

     if (prefixSums.indexOf(current-sum) != -1)

          result++;

     }

    prefixSum.add(current);

   }

   return result;

   } 

}

Sample: targetSum = -3; Answer: 1

Numbers: 2, 2, -4, 1, 1, 2

prefixSum:  2, 4,  0, 1, 2, 4

#drones: MeshUAV.docx

 This is a summary of the book titled “Self Less: Lessons learned from a life devoted to Servant Leadership, in five acts” written by Len Jessup and published by ForbesBooks in 2024. The author shares his experience, insights and advice on how to take positive action. He distinguishes between “selfless” as putting others first and “self-less” as acting to benefit others. He keeps his narrative strictly about his experiences, but he advocates for putting others first at work and at home. He calls out a “five-act structure” from playwrights to lay out his narrative and to pass on his leadership lessons. Act 1covers his origins where he claims your background can help or hinder you. Act 2 is about beliefs which pave the way for your unique leadership style. Act 3 is about adversity which identifies the sources of opposition and how to overcome them. Act 4 is about impact because we don’t have unlimited time, and Act 5 is legacy and how to plan it.

Great leaders are selfless and self less, focusing on the needs of their team members rather than their own. This concept was introduced by Len Jessup after his divorce and his subsequent role as a peer committee chair. He realized the importance of putting others first and engaging in actions that benefit others. Selfless leadership involves putting others' needs first, rather than one's own. This concept is exemplified by the concept of "level five" leadership, which emphasizes self-awareness and humility while driven to succeed.

Organizations run by selfless leaders work "bottom-up," not "top-down," and are democratic, inclusive, collaborative, and open. They surround themselves with smarter team members, demonstrating their acuity as leaders who strive for the best possible results. Selfless leadership is a powerful tool for leading others through transformational organizational changes, where a team's shared vision and fulfillment count more than the leader's vision or fulfillment.

Success at a high level requires the wholehearted buy-in of those you lead, whether a small team or a full workforce. To gain the support of people you're leading, don't be the one who is selfless.

Jessup's early life was influenced by both positive and negative factors, but he felt a strong commitment to help others succeed in higher education. To determine the impact of your origins, consider how they influenced your current situation and future direction. Beliefs play a crucial role in leadership, as you must consistently exhibit the right values and ensure your team's success. Identifying limiting beliefs and seeking ways to move beyond them can help you lead effectively. During Jessup's presidency at the University of Nevada, he faced criticism from the Board of Regents, but his wife Kristi provided perspective and encouragement. Everyone needs encouragement to stay positive and focused, especially in times of change.

Adversity can arise from various sources, including environmental factors and negative people within an organization. Leaders must learn to overcome opposition and serve and support their team to succeed. Success is hard, and leaders must consider the weight of their strength, endurance, patience, and resilience.

To make a positive impact, consider the impact on others and plan how to serve them. Ensure employees have the resources and time to perform their jobs effectively, build in fun and good times, and find small steps to increase employee happiness.

Being a true leader requires courage and the ability to serve others. Leaders should make the most of their time and be a positive influence on their family, friends, peers, subordinates, company, and the world around them. By doing what they can, leaders can make a difference in many ways and contribute to the success of their organization.

Jessup raised nearly a billion dollars in donations and in-kind gifts for his university. He initially focused on teaching and research but realized the importance of philanthropy. He identified potential donors and successfully solicited their contributions. Jessup views the money he raised as his legacy and encourages other leaders to examine their daily lessons, as they will become their legacy in time. He believes leadership is a gift and privilege, and leaders should remain "self less as a state of action" to learn and leave a worthwhile legacy.

#codingexercise: CodingExercise-11-16-2024.docx