Camionix

camionix

Fukui functions function as basic descriptors from DFT-based conceptual density functional theory, which shows how electrons distribute within molecules. The prediction capability using these functions reveals the electron-donating or accepting the potential of molecules at specific atomic sites to determine electrophilic or nucleophilic characteristics. The dual descriptor enhances Fukui function analysis by distinguishing the nucleophilic and electrophilic properties at molecular sites which improves the accuracy of chemical reactivity assessments. We have found that most researchers are facing challenges in calculating these important descriptors for an advanced scientific analysis. Here, we have designed a simple Python code to simplify the calculation. The article provides detailed insights into Fukui functions, together with their theoretical framework, along with numerical procedures and Python application utilizing Natural Population Analysis (NPA) results obtained from Gaussian software. 📥Fukui Functions and Their Physical Interpretation The Fukui function 𝑓(𝑟) measures the response of electron density ρ(r) when the number of electrons in a system changes slightly. Mathematically, it is defined as: Where N is the total number of electrons, and v(r) is the external potential. This function can be numerically approximated using finite differences: Where: 𝑞 𝑟 ( 𝑁 )  → the atomic charge of a particular site in a neutral molecule.
𝑞 𝑟 ( 𝑁 + 1 )  → the charge after adding an electron (anion).
𝑞 𝑟 ( 𝑁 − 1 ) → the charge after removing an electron (cation). The two functions evaluate electron density sensitivity toward altering conditions to help predict chemical reactivity patterns. 📥Dual Descriptor (Δ𝑓(𝑟))  and Chemical Interpretation The dual descriptor Δ 𝑓 ( 𝑟 )  refines Fukui function analysis by differentiating between electrophilic and nucleophilic reactive sites: 📥Interpretation of Δ𝑓( 𝑟 ) : Δ 𝑓 ( 𝑟 ) → Region favors nucleophilic attack.
Δ 𝑓 ( 𝑟 ) < 0  → Region favors electrophilic attack.
Δ 𝑓 ( 𝑟 )=0 → Region is chemically inert. By using Δ 𝑓 ( 𝑟 ), researchers can precisely determine reactive molecular sites and predict the pathways of organic reactions. 📥Natural Population Analysis (NPA) in Gaussian Computational chemistry employs NPA extensively to divide electron density across the molecule’s atoms. Gaussian software generates NPA charges through the input file keyword Pop=NPA. The basis for performing Fukui function calculations is provided by these charges. Example Gaussian Input for NPA Calculation: %chk=mol.chk
# B3LYP/6-31G(d,p) Pop=NPA

Title: NPA Charge Calculation

0 1
C   0.000   0.000   0.000
H   0.000   0.000   1.090
H   1.026   0.000  -0.363
H  -0.513  -0.889  -0.363
H  -0.513   0.889  -0.363 The output section of the Gaussian calculation provides NPA charges under the "Natural Population Analysis" heading. The extracted charges are formatted in a table: These values are used in the Python script to compute Fukui functions and the dual descriptor. 📥Python Code for Fukui Function Calculation Researchers use the calculated values to understand chemical mechanisms during reactions while developing molecules that possess particular functional properties including catalysts and drug candidates. 👉Python Script: import pandas as pd

# Load the data from the Excel file in the same directory as the script
file_path = 'FUKUI.xlsx'
df = pd.read_excel(file_path)

# Calculate Fukui Functions and Dual Descriptor with 5 decimal places
df['fr+'] = (df['Anion(N+1)'] - df['Neutral(N)']).apply(lambda x: f"{x:.5f}")
df['fr-'] = (df['Neutral(N)'] - df['Cation(N-1)']).apply(lambda x: f"{x:.5f}")
df['fr0'] = ((df['Anion(N+1)'] - df['Cation(N-1)']) / 2).apply(lambda x: f"{x:.5f}")
df['∆f'] = (df['fr+'].astype(float) - df['fr-'].astype(float)).apply(lambda x: f"{x:.5f}")

# Save the calculated data to a new Excel file in the same directory
output_file = 'fukui_functions_output.xlsx'
df.to_excel(output_file, index=False)

# Display the DataFrame (optional)
print(df) 👉Code Explanation: Loading Data: Reads NPA charges from an Excel file (FUKUI.xlsx). Just execute the above Python code. Please properly arrange the charges from NPA analysis in the input file, sayFUKUI.xlsx ,exactly as shown in Figure 1. Also, make sure the Python script and your input file exist in the same directory. 👉Fukui Function Calculation: The 𝑓+( 𝑟 ) index derives from the difference between anionic and neutral charge values.
This index 𝑓-( 𝑟 ) results from subtracting the cationic charge value from the neutral charge value.
The radical Fukui function obtains its value by performing an average operation on 𝑓+( 𝑟 ) and 𝑓-( 𝑟 ).
A dual descriptor emerges when the calculation of 𝑓-( 𝑟 )  subtracts 𝑓+( 𝑟 )  from it. Formatting: Each value is rounded to five decimal places for precision. Output: The results are saved as fukui_functions_output.xlsx for further analysis. 📥Results and Discussion The calculated Fukui functions and dual descriptors provide critical insights into molecular reactivity: High 𝑓+( 𝑟 ) values indicate potential nucleophilic sites.
High 𝑓−( 𝑟 ) values suggest electrophilic reactivity.
Δ 𝑓 ( 𝑟 )  values induce the most reactive sites. Predictions of reaction mechanisms pair with the production of molecules with particular desired properties such as catalysts and drug candidates. 📥Conclusion The combination of Fukui functions with dual descriptors functions as a strong computational approach for exploring chemical reactivity. Proper calculation of charge distributions depends on NPA charges obtained through Gaussian calculations. The Python-based methodology enables automation that makes it possible for efficient evaluation of big molecular datasets. Next studies should implement combined analysis of Fukui functions together with electrostatic potential mapping which includes molecular orbital analysis to achieve a proper understanding of reactivity behavior. Fukui functions function as basic descriptors from DFT-based conceptual density functional theory, which shows how electrons distribute within molecules. The prediction capability using these functions reveals the electron-donating or accepting the potential of molecules at specific atomic sites to determine electrophilic or nucleophilic characteristics. The dual descriptor enhances Fukui function analysis by distinguishing the nucleophilic and electrophilic properties at molecular sites which improves the accuracy of chemical reactivity assessments. We have found that most researchers are facing challenges in calculating these important descriptors for an advanced scientific analysis. Here, we have designed a simple Python code to simplify the calculation. The article provides detailed insights into Fukui functions, together with their theoretical framework, along with numerical procedures and Python application utilizing Natural Population Analysis (NPA) results obtained from Gaussian software. 📥Fukui Functions and Their Physical Interpretation 📥Fukui Functions and Their Physical Interpretation The Fukui function 𝑓(𝑟) measures the response of electron density ρ(r) when the number of electrons in a system changes slightly. Mathematically, it is defined as: Where N is the total number of electrons, and v(r) is the external potential. This function can be numerically approximated using finite differences: Where: 𝑞 𝑟 ( 𝑁 )  → the atomic charge of a particular site in a neutral molecule. 𝑞 𝑟 ( 𝑁 + 1 )  → the charge after adding an electron (anion). 𝑞 𝑟 ( 𝑁 − 1 ) → the charge after removing an electron (cation). 𝑞 𝑟 ( 𝑁 )  → the atomic charge of a particular site in a neutral molecule. 𝑞 𝑟 ( 𝑁 + 1 )  → the charge after adding an electron (anion). 𝑞 𝑟 ( 𝑁 − 1 ) → the charge after removing an electron (cation). The two functions evaluate electron density sensitivity toward altering conditions to help predict chemical reactivity patterns. 📥Dual Descriptor (Δ𝑓(𝑟))  and Chemical Interpretation The dual descriptor Δ 𝑓 ( 𝑟 )  refines Fukui function analysis by differentiating between electrophilic and nucleophilic reactive sites: 📥Interpretation of Δ𝑓( 𝑟 ) : Δ 𝑓 ( 𝑟 ) → Region favors nucleophilic attack. Δ 𝑓 ( 𝑟 ) < 0  → Region favors electrophilic attack. Δ 𝑓 ( 𝑟 )=0 → Region is chemically inert. Δ 𝑓 ( 𝑟 ) → Region favors nucleophilic attack . nucleophilic attack Δ 𝑓 ( 𝑟 ) < 0  → Region favors electrophilic attack . electrophilic attack Δ 𝑓 ( 𝑟 )=0 → Region is chemically inert . chemically inert By using Δ 𝑓 ( 𝑟 ), researchers can precisely determine reactive molecular sites and predict the pathways of organic reactions. 📥Natural Population Analysis (NPA) in Gaussian Computational chemistry employs NPA extensively to divide electron density across the molecule’s atoms. Gaussian software generates NPA charges through the input file keyword Pop=NPA . The basis for performing Fukui function calculations is provided by these charges. Pop=NPA Example Gaussian Input for NPA Calculation: %chk=mol.chk
# B3LYP/6-31G(d,p) Pop=NPA

Title: NPA Charge Calculation

0 1
C   0.000   0.000   0.000
H   0.000   0.000   1.090
H   1.026   0.000  -0.363
H  -0.513  -0.889  -0.363
H  -0.513   0.889  -0.363 %chk=mol.chk
# B3LYP/6-31G(d,p) Pop=NPA

Title: NPA Charge Calculation

0 1
C   0.000   0.000   0.000
H   0.000   0.000   1.090
H   1.026   0.000  -0.363
H  -0.513  -0.889  -0.363
H  -0.513   0.889  -0.363 The output section of the Gaussian calculation provides NPA charges under the "Natural Population Analysis" heading. The extracted charges are formatted in a table: " Natural Population Analysis " Natural Population Analysis These values are used in the Python script to compute Fukui functions and the dual descriptor. 📥Python Code for Fukui Function Calculation 📥Python Code for Fukui Function Calculation Researchers use the calculated values to understand chemical mechanisms during reactions while developing molecules that possess particular functional properties including catalysts and drug candidates. 👉Python Script: 👉Python Script: import pandas as pd

# Load the data from the Excel file in the same directory as the script
file_path = 'FUKUI.xlsx'
df = pd.read_excel(file_path)

# Calculate Fukui Functions and Dual Descriptor with 5 decimal places
df['fr+'] = (df['Anion(N+1)'] - df['Neutral(N)']).apply(lambda x: f"{x:.5f}")
df['fr-'] = (df['Neutral(N)'] - df['Cation(N-1)']).apply(lambda x: f"{x:.5f}")
df['fr0'] = ((df['Anion(N+1)'] - df['Cation(N-1)']) / 2).apply(lambda x: f"{x:.5f}")
df['∆f'] = (df['fr+'].astype(float) - df['fr-'].astype(float)).apply(lambda x: f"{x:.5f}")

# Save the calculated data to a new Excel file in the same directory
output_file = 'fukui_functions_output.xlsx'
df.to_excel(output_file, index=False)

# Display the DataFrame (optional)
print(df) import pandas as pd

# Load the data from the Excel file in the same directory as the script
file_path = 'FUKUI.xlsx'
df = pd.read_excel(file_path)

# Calculate Fukui Functions and Dual Descriptor with 5 decimal places
df['fr+'] = (df['Anion(N+1)'] - df['Neutral(N)']).apply(lambda x: f"{x:.5f}")
df['fr-'] = (df['Neutral(N)'] - df['Cation(N-1)']).apply(lambda x: f"{x:.5f}")
df['fr0'] = ((df['Anion(N+1)'] - df['Cation(N-1)']) / 2).apply(lambda x: f"{x:.5f}")
df['∆f'] = (df['fr+'].astype(float) - df['fr-'].astype(float)).apply(lambda x: f"{x:.5f}")

# Save the calculated data to a new Excel file in the same directory
output_file = 'fukui_functions_output.xlsx'
df.to_excel(output_file, index=False)

# Display the DataFrame (optional)
print(df) 👉Code Explanation: Loading Data: Loading Data: Reads NPA charges from an Excel file ( FUKUI.xlsx ). FUKUI.xlsx Just execute the above Python code. Please properly arrange the charges from NPA analysis in the input file, sayFUKUI.xlsx ,exactly as shown in Figure 1. Also, make sure the Python script and your input file exist in the same directory. Just execute the above Python code. Please properly arrange the charges from NPA analysis in the input file, say FUKUI.xlsx ,exactly as shown in Figure 1. Also, make sure the Python script and your input file exist in the same directory. FUKUI.xlsx 👉Fukui Function Calculation: The 𝑓+( 𝑟 ) index derives from the difference between anionic and neutral charge values. This index 𝑓-( 𝑟 ) results from subtracting the cationic charge value from the neutral charge value. The radical Fukui function obtains its value by performing an average operation on 𝑓+( 𝑟 ) and 𝑓-( 𝑟 ). A dual descriptor emerges when the calculation of 𝑓-( 𝑟 )  subtracts 𝑓+( 𝑟 )  from it. The 𝑓+( 𝑟 ) index derives from the difference between anionic and neutral charge values. 𝑓+( 𝑟 ) This index 𝑓-( 𝑟 ) results from subtracting the cationic charge value from the neutral charge value. 𝑓-( 𝑟 ) The radical Fukui function obtains its value by performing an average operation on 𝑓+( 𝑟 ) and 𝑓-( 𝑟 ) . 𝑓+( 𝑟 ) 𝑓-( 𝑟 ) A dual descriptor emerges when the calculation of 𝑓-( 𝑟 ) subtracts 𝑓+( 𝑟 ) from it. 𝑓-( 𝑟 ) 𝑓+( 𝑟 ) Formatting: Each value is rounded to five decimal places for precision. Formatting: Output: The results are saved as fukui_functions_output.xlsx for further analysis. Output: fukui_functions_output.xlsx 📥Results and Discussion The calculated Fukui functions and dual descriptors provide critical insights into molecular reactivity: High 𝑓+( 𝑟 ) values indicate potential nucleophilic sites. High 𝑓−( 𝑟 ) values suggest electrophilic reactivity. Δ 𝑓 ( 𝑟 )  values induce the most reactive sites. High 𝑓+( 𝑟 ) values indicate potential nucleophilic sites. High 𝑓+( 𝑟 ) High 𝑓−( 𝑟 ) values suggest electrophilic reactivity. High 𝑓−( 𝑟 ) Δ 𝑓 ( 𝑟 ) values induce the most reactive sites. Δ 𝑓 ( 𝑟 ) Predictions of reaction mechanisms pair with the production of molecules with particular desired properties such as catalysts and drug candidates. 📥Conclusion The combination of Fukui functions with dual descriptors functions as a strong computational approach for exploring chemical reactivity. Proper calculation of charge distributions depends on NPA charges obtained through Gaussian calculations. The Python-based methodology enables automation that makes it possible for efficient evaluation of big molecular datasets. Next studies should implement combined analysis of Fukui functions together with electrostatic potential mapping which includes molecular orbital analysis to achieve a proper understanding of reactivity behavior.

Fukui Functions and Dual Descriptors Explained: An Advanced Scientific Analysis 

Fukui-funksies en dubbele beskrywings verduidelik: 'n gevorderde wetenskaplike analise 

Explicación de las funciones de Fukui y los descriptores duales: un análisis científico avanzado

Fukui-funktiot ja kaksoiskuvaajat selitettyinä: Kehittynyt tieteellinen analyysi 

Fonksyon Fukui ak Deskriptè Doub Eksplike: Yon Analiz Syantifik Avanse 

福井関数と二重記述子の説明: 高度な科学的分析

Функциите на Фукуи и двојните дескриптори Објаснети: Напредна научна анализа 

Mešomo ya Fukui le Ditlhaloši tše Pedi tše di Hlalošitšwego: Tshekatsheko ya Mahlale ya Maemo a Godimo 

Funkcje Fukui i deskryptory dualne wyjaśnione: zaawansowana analiza naukowa

Funcțiile Fukui și descriptorii duali explicați: o analiză științifică avansată 

Функсияҳои Фукуи ва тавсифкунандагони дугона: Таҳлили пешрафтаи илмӣ 

ተግባራት ፉኩይን ድርብ መግለጺታትን ተገሊጹ፡ ምዕቡል ሳይንሳዊ ትንተና 

Ipinaliwanag ang Mga Function ng Fukui at Dual Descriptor: Isang Advanced na Scientific Analysis 

Currently, 50% of advanced IT departments have invested in artificial intelligence, and another 20% plan to do so by the end of 2024. Even less advanced organizations are starting to invest in AI, with 35% jumping on board this year. This means it’s essential for CTOs to know how to use AI in order to keep their companies ahead and competitive. For 22-year-old co-founder and CTO of Lumaa, Luis Fernando, driving innovation with AI isn’t just about technical skills. It’s about embracing the unexpected, iterating quickly, and leaning on industry experts. Follow Luis Fernando’s unique journey into software engineering and AI innovation, and learn the valuable lessons he’s picked up that can help startup CTOs in any industry. From Teen Coder to CTO Luis Fernando started coding at just 14 years old, exploring and experimenting with various programming languages and projects. This laid the foundation for an impressive career in software engineering and AI innovation. In 2020, he deferred university for a year due to the COVID pandemic and began working professionally as a Junior Software Engineer in his hometown of Feira de Santana, Brazil. Following that, he went from transforming system infrastructures at a London startup to handling high-stakes government projects at Microsoft. Throughout his journey, Luis has consistently taken on new challenges and leadership roles, whether it was revamping platforms, managing logistics, or guiding teams. As a Peer Programming Instructor, he honed his teaching skills and mentored fellow coders, while his leadership in the Brazilian Students Association involved coordinating large-scale events and managing diverse teams. His diverse background equips him with the unique skills and insights needed to drive AI innovation as a CTO at Lumaa, which he co-founded with Madhumitha Somu Dinakaran. Madhu Dinakaran: a Partner in Innovation Madhumitha Dinakaran left home at 14 after raising $250k in scholarships to study in 12 different countries through Think Global School. Through TGS, she focused on the modern educational approach of active-based learning — working on projects instead of taking tests. In Panama, she created goggles for the visually impaired, and in Japan, she made a VR film about the Hiroshima bombing — a project that was showcased at a UN session in Germany. After graduating high school in 2021, she got $100k in scholarships to study at Minerva University, majoring in Social Sciences and Arts & Humanities. At Minerva, she worked as a Student Life Intern, helping integrate remote students into the community. During her time in South Korea, Madhu designed a community project to combat loneliness among the elderly using art. In Argentina, she worked as a UI/UX designer to develop a landing page for Caminito, showcasing the stories of Buenos Aires residents. While in Argentina, she also began research on procurement for Lumaa. In January 2024, Madhu moved to San Francisco to focus full-time on Lumaa with Luis. Lumaa Created by Luis and Madhu, Lumaa is a platform that automates vendor responses to RFPs and security questionnaires. This automated workflow saves time and money for companies bidding on new projects by quickly generating precise responses, eliminating the need for teams to manually craft each answer. This allows organizations to focus on other important tasks and reduces the need for additional resources. Luis Fernando’s Insights for AI-Minded CTOs Thanks to his storied history of working with AI and tech innovation at large, Luis has developed several insights for other CTOs working with AI. Embrace Unexpected Challenges When Luis started his first job as a junior software engineer, the senior engineer left just two weeks later. Suddenly, he was the only engineer on the team, and he had very little professional experience. This unexpected challenge forced him to quickly learn and adapt, suddenly having to manage a huge codebase and create new features on his own. This experience taught him a lot about problem-solving and innovation under pressure. For CTOs harnessing and adapting to AI technologies, unexpected challenges are even more frequent and complex. In fact, around 66% of CTOs believe that their current network infrastructure lacks the capacity to effectively support generative AI, while 76% report feeling increasing pressure to make it work. In Luis’s view, the key to AI innovation is seeing these challenges as chances to improve. For example, leveraging generative AI might be difficult, but it could speed up data processing and allow for real-time analytics. This can better inform CTOs’ decision-making and make their day-to-day operations more efficient. So tackling these issues head-on not only fixes current problems but also prepares organizations for future growth in an increasingly AI world. Iterate Quickly and Efficiently When adopting AI tools, a CTO should be able to develop a basic model or prototype to demonstrate its core functionality to customers or stakeholders. However, this basic model doesn’t have to be perfect. This means that for Luis, gone are the days of sweating over a painstaking design process before meeting with potential users. Instead, he realized that a CTO’s role is about determining the best technological steps for the company and its customers, not building robust solutions right off the bat. “Back in April,” he explains, “I was trying to build a fully-fledged working code to show people, and I got very attached to the solution I was creating. Now, with a demo next week, I’m just going to build a simple Python script that can be shown online, where people can upload files and see the output in the console.” This approach keeps Luis flexible and responsive to feedback so that he can quickly build prototypes that address his users’ actual needs. Learn From Industry Experts Luis also stresses the importance of connecting with other industry experts to drive AI innovation. After all, tech is always changing, and no CTO or developer can know everything. Talking to other professionals helps innovators stay updated and gain new insights from those with years of experience and honed skills. For example, engaging with experts in different areas can provide new avenues for improving products that rely on AI. Luis explains,"You can use their knowledge to write better code, improve your product, enhance your minimum viable product, and ultimately take your startup to the next level — attracting more clients in the process.” Leading AI Innovation as a CTO Driving AI innovation is a key responsibility for CTOs, and Luis Fernando shows how to do it right. From handling unexpected challenges to quickly iterating and learning from others in the field, his journey offers important lessons. His approach highlights the importance of being flexible, taking feedback seriously, and using the expertise of others to address the real-world needs of customers. By following his insights, CTOs can help their companies stay ahead in an increasingly AI-driven marketplace. For more tips and practical advice on leading AI innovation, follow Luis Fernando’s story, and see how you can apply these strategies in your own role as a CTO. Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. Currently, 50% of advanced IT departments have invested in artificial intelligence, and another 20% plan to do so by the end of 2024. Even less advanced organizations are starting to invest in AI, with 35% jumping on board this year. 50% of advanced IT departments 50% of advanced IT departments This means it’s essential for CTOs to know how to use AI in order to keep their companies ahead and competitive. For 22-year-old co-founder and CTO of Lumaa, Luis Fernando, driving innovation with AI isn’t just about technical skills. It’s about embracing the unexpected, iterating quickly, and leaning on industry experts. Follow Luis Fernando’s unique journey into software engineering and AI innovation, and learn the valuable lessons he’s picked up that can help startup CTOs in any industry. From Teen Coder to CTO Luis Fernando started coding at just 14 years old, exploring and experimenting with various programming languages and projects. This laid the foundation for an impressive career in software engineering and AI innovation. In 2020, he deferred university for a year due to the COVID pandemic and began working professionally as a Junior Software Engineer in his hometown of Feira de Santana, Brazil. Following that, he went from transforming system infrastructures at a London startup to handling high-stakes government projects at Microsoft. Throughout his journey, Luis has consistently taken on new challenges and leadership roles, whether it was revamping platforms, managing logistics, or guiding teams. As a Peer Programming Instructor, he honed his teaching skills and mentored fellow coders, while his leadership in the Brazilian Students Association involved coordinating large-scale events and managing diverse teams. His diverse background equips him with the unique skills and insights needed to drive AI innovation as a CTO at Lumaa, which he co-founded with Madhumitha Somu Dinakaran . Madhumitha Somu Dinakaran Madhumitha Somu Dinakaran Madhu Dinakaran: a Partner in Innovation Madhumitha Dinakaran left home at 14 after raising $250k in scholarships to study in 12 different countries through Think Global School. Through TGS, she focused on the modern educational approach of active-based learning — working on projects instead of taking tests. In Panama, she created goggles for the visually impaired, and in Japan, she made a VR film about the Hiroshima bombing — a project that was showcased at a UN session in Germany. After graduating high school in 2021, she got $100k in scholarships to study at Minerva University, majoring in Social Sciences and Arts & Humanities. At Minerva, she worked as a Student Life Intern, helping integrate remote students into the community. During her time in South Korea, Madhu designed a community project to combat loneliness among the elderly using art. In Argentina, she worked as a UI/UX designer to develop a landing page for Caminito, showcasing the stories of Buenos Aires residents. While in Argentina, she also began research on procurement for Lumaa. In January 2024, Madhu moved to San Francisco to focus full-time on Lumaa with Luis. Lumaa Created by Luis and Madhu, Lumaa is a platform that automates vendor responses to RFPs and security questionnaires. This automated workflow saves time and money for companies bidding on new projects by quickly generating precise responses, eliminating the need for teams to manually craft each answer. This allows organizations to focus on other important tasks and reduces the need for additional resources. Luis Fernando’s Insights for AI-Minded CTOs Thanks to his storied history of working with AI and tech innovation at large, Luis has developed several insights for other CTOs working with AI. Embrace Unexpected Challenges When Luis started his first job as a junior software engineer, the senior engineer left just two weeks later. Suddenly, he was the only engineer on the team, and he had very little professional experience. This unexpected challenge forced him to quickly learn and adapt, suddenly having to manage a huge codebase and create new features on his own. This experience taught him a lot about problem-solving and innovation under pressure. For CTOs harnessing and adapting to AI technologies, unexpected challenges are even more frequent and complex. In fact, around 66% of CTOs believe that their current network infrastructure lacks the capacity to effectively support generative AI, while 76% report feeling increasing pressure to make it work. around 66% of CTOs around 66% of CTOs In Luis’s view, the key to AI innovation is seeing these challenges as chances to improve. For example, leveraging generative AI might be difficult, but it could speed up data processing and allow for real-time analytics. This can better inform CTOs’ decision-making and make their day-to-day operations more efficient. So tackling these issues head-on not only fixes current problems but also prepares organizations for future growth in an increasingly AI world. Iterate Quickly and Efficiently When adopting AI tools, a CTO should be able to develop a basic model or prototype to demonstrate its core functionality to customers or stakeholders. However, this basic model doesn’t have to be perfect. This means that for Luis, gone are the days of sweating over a painstaking design process before meeting with potential users. Instead, he realized that a CTO’s role is about determining the best technological steps for the company and its customers, not building robust solutions right off the bat. “Back in April,” he explains, “I was trying to build a fully-fledged working code to show people, and I got very attached to the solution I was creating. Now, with a demo next week, I’m just going to build a simple Python script that can be shown online, where people can upload files and see the output in the console.” This approach keeps Luis flexible and responsive to feedback so that he can quickly build prototypes that address his users’ actual needs. Learn From Industry Experts Luis also stresses the importance of connecting with other industry experts to drive AI innovation. After all, tech is always changing, and no CTO or developer can know everything. Talking to other professionals helps innovators stay updated and gain new insights from those with years of experience and honed skills. For example, engaging with experts in different areas can provide new avenues for improving products that rely on AI. Luis explains,"You can use their knowledge to write better code, improve your product, enhance your minimum viable product, and ultimately take your startup to the next level — attracting more clients in the process.” Leading AI Innovation as a CTO Driving AI innovation is a key responsibility for CTOs, and Luis Fernando shows how to do it right. From handling unexpected challenges to quickly iterating and learning from others in the field, his journey offers important lessons. His approach highlights the importance of being flexible, taking feedback seriously, and using the expertise of others to address the real-world needs of customers. By following his insights, CTOs can help their companies stay ahead in an increasingly AI-driven marketplace. For more tips and practical advice on leading AI innovation, follow Luis Fernando’s story , and see how you can apply these strategies in your own role as a CTO. follow Luis Fernando’s story follow Luis Fernando’s story Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. Vested Interest Disclosure : This author is an independent contributor publishing via our business blogging program. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. Vested Interest Disclosure

3 Startup CTO Insights from Luis Fernando: Driving Technological Innovation with AI

লুইস ফার্নান্দো থেকে 3 স্টার্টআপ CTO অন্তর্দৃষ্টি: AI এর সাথে প্রযুক্তিগত উদ্ভাবন চালানো

3 Startup-CTO-Einblicke von Luis Fernando: Technologische Innovation mit KI vorantreiben

3 ideas del CTO de startups de Luis Fernando: impulsar la innovación tecnológica con IA

3 idées du CTO de startup de Luis Fernando : stimuler l'innovation technologique avec l'IA

लुइस फर्नांडो से 3 स्टार्टअप सीटीओ अंतर्दृष्टि: एआई के साथ तकनीकी नवाचार को आगे बढ़ाना

ルイス・フェルナンドによるスタートアップCTOの3つの洞察: AIによる技術革新の推進

Luis Fernando가 전하는 3가지 스타트업 CTO 통찰: AI를 통한 기술 혁신 추진

3 insights do CTO de startups de Luis Fernando: Impulsionando a inovação tecnológica com IA

3 идеи технического директора стартапа от Луиса Фернандо: внедрение технологических инноваций с помощью искусственного интеллекта

Luis Fernando'dan 3 Startup CTO İçgörüsü: Yapay Zeka ile Teknolojik İnovasyonu Desteklemek

3 cái nhìn sâu sắc về CTO khởi nghiệp từ Luis Fernando: Thúc đẩy đổi mới công nghệ bằng AI

Luis Fernando 的 3 大初创公司 CTO 见解：利用 AI 推动技术创新

THE SUBMERGENCE OF THE OLD WORLD

How does Deep overcome this hurdle in machine learning and why? Learning To begin we should clearly define the Curse of Dimensionality: A phenomena that occurs when the dimensionality of the data increases, the sparsity of the data increases. Data has dimensionality to it. The more dimensions that are added to the data, the more difficult it becomes to find patterns. Think about dimensionality as the range of movement of an animal you’re playing tag with. If you’re chasing an animal that can only move on the ground they can only go in 2 dimensions left or right(x), forward or backward(y). It’s harder to catch a bird because that bird can move in 3 dimensions left or right (x), forward or backward (y), up or down (z). We can imagine some mythical time traveling beast that can move in 4 dimensions left or right(x), forward or backward(y), up or down(z), past or future(t). You can see this gets more difficult as the dimensions increase. This same problem applies with data and machine learning. As the data’s dimensionality increases the sparsity of the data increases making it harder to ascertain a pattern. There are certain ways around the curse of dimensionality in traditional ML that require certain techniques such as function smoothing and approximation. Deep Learning has overcome this “curse” by it’s inherent nature and may be one of the contributions to the increased popularity. Deep Learning In high dimensionality applications deep learning does not suffer from the same consequences as other machine learning algorithms such as Linear Regression. This fact is part of the magic that makes this methodology of modeling with Neural Networks so effective. Neural Network’s imperviousness to the curse of dimensionality is a helpful characteristic in today’s world of big data. There are multiple theories on why this occurs. We will now quickly go over the main ideas of each: Linear Manifold Manifold Hypothesis [1] At a high level the Manifold Hypothesis suggests that high dimensional data actually sits on a lower dimensional manifold embedded in higher dimensional space. In a hand-wavey sense this nearly means that in this high dimensional data there is some underlying pattern in lower level dimensions that deep learning methods are good at exploiting. So given a high dimensional matrix that represents images, neural networks excel at finding low dimensional features that are not apparent in the high dimensional representation. Image from deep learning book. Manifold over high dimensional data The image above represents a bunch of data points in a high dimensional space. It is in 2-d for easy representation on this blog post. The with a line between the points shows that there is some manifold in this high dimensional space where most of the data lies. That manifold is the line that connects all the points. Neural networks and Deep Learning methods exploit that and theoretically find that manifold. Visualization of activations from different neurons of a Convolution Neural Network Sparse Coding [2] This is the occurrence when the data flows through the different neurons in a network. Each neuron in the Neural network has it’s own activation functions. When each neuron fires on it’s activation it is causing sparse coding. The image above depicts the visualization of activations of a neural network. Each individual neuron is picking up on a different feature found from being fed an image. The representation above shows how the different neurons pick up on different features and each individually contribute to the final output of the network. For example the English language is composed of 26 letters. These letters can make all the words of the language. In terms of neural networks there are some number of neurons that when fired can be combined with the firing of other neurons to combine to output the correct answer no matter the dimensionality of the inputs. Conclusion There’s no sole proven theory that indicates why Neural Networks overcome the curse of dimensionality. There’s a lot of research going on to understand the different aspects and underlying characteristics that allow Deep Learning and Neural networks to be so effective in practice. Until then we have a good idea on what types of concepts are going on under the hood, that help fuel deep learning and neural networks to be used in practice. For more Deep Learning articles check out camron.xyz Further Reading: Manifold Hypothesis [1]: https://www.ima.umn.edu/2008-2009/SW10.27-30.08/6687 Deep Learning [1]: Book http://www.deeplearningbook.org/version-2015-10-03/contents/manifolds.html [1] & [2] Lecture from Partha Niyogi: https://www.ima.umn.edu/2008-2009/SW10.27-30.08/6687 Wikipedia [2]: https://en.wikipedia.org/wiki/Neural_coding#Sparse_coding Writeup on Sparse Coding [2]: http://redwood.berkeley.edu/vs265/handout-sparse-08.pdf Inspired by this reddit post: https://goo.gl/jJFtP1

What Killed the Curse of Dimensionality?

Deep can be overwhelming when new to the subject. Here are some cheats and tips to get you through it. Learning What’re Those?!?! In this article we will go over common concepts found in Deep Learning to help get started on this amazing subject. Visualization of gradient. The red arrows are the gradient of the blue plotted function. Gradient ∇ (Nabla) The gradient is the partial derivative of a function that takes in multiple vectors and outputs a single value (i.e. our cost functions in Neural Networks). The gradient tells us which direction to go on the graph to increase our output if we increase our variable input. We use the gradient and go in the opposite direction since we want to decrease our loss. Back Propagation Also known as back prop, this is the process of back tracking errors through the weights of the after forward propagating inputs through the network. This is used by applying the chain rule in calculus. network Sigmoid σ A function used to activate weights in our network in the interval of [0, 1]. This function graphed out looks like an ‘S’ which is where this function gets is name, the s is sigma in greek. Also known as the logistic function Formula for ReLU from Geoffrey Hinton Rectified Linear Units or ReLU The sigmoid function has an interval of [0,1], while the ReLU has a range from [0, infinity]. This means that the sigmoid is better for logistic regression and the ReLU is better at representing positive numbers. The ReLU do not suffer from the vanishing gradient problem. Tanh function Tanh Tanh is a function used to initialize the weights of your network of [-1, 1]. Assuming your data is normalized we will have stronger gradients: since data is centered around 0, the derivatives are higher. To see this, calculate the derivative of the tanh function and notice that input values are in the range [0,1].The range of the tanh function is [-1,1] and that of the sigmoid function is [0,1]. This also avoids bias in the gradients. LSTM/GRU Typically found in Recurrent Neural Networks but are expanding to use in others these are little “memory units” that keep state between inputs for training and help solve the vanishing gradient problem where after around 7 time steps an RNN loses context of the input prior. Softmax Softmax is a function usually used at the end of a Neural Network for classification. This function does a multinomial logistic regression and is generally used for multi class classification. Usually paired with cross entropy as the loss function. L1 and L2 Regularization These regularization methods prevent overfitting by imposing a penalty on the coefficients. L1 can yield sparse models while L2 cannot. Regularization is used to specify model complexity. This is important because it allows your model to generalize better and not overfit to the training data. Drop out [1] “It prevents overfitting and provides a way of approximately combining exponentially many different neural network architectures efficiently“(Hinton). This method randomly picks visible and hidden units to drop from the network. This is usually determined by picking a layer percentage dropout. Batch Normalization [1] When networks have many deep layers there becomes an issue of internal covariate shift. The shift is “the change in the distribution of network activations due to the change in network parameters during training.” (Szegedy). If we can reduce internal covariate shift we can train faster and better. Batch Normalization solves this problem by normalizing each batch into the network by both mean and variance. Objective Functions Also known as or . The goal of a network is to minimize the loss to maximize the accuracy of the network. loss function, cost function opimization score function A more technical explanation [3]: The loss/cost/optimization/objective function is the function that is computed on the prediction of your network. Your network will output a prediction, y_hat which we will compare to the desired output of y. This function then is used in back propagation to give us our gradient to allow our network to be optimized. Examples of these functions are f1/f score, categorical cross entropy, mean squared error, mean absolute error, hinge loss… etc. F1/F Score A measure of how accurate a model is by using precision and recall following a formula of: F1 = 2 * (Precision * Recall) / (Precision + Recall) Precise: of every prediction which ones are actually positive? Precision = True Positives / (True Positives + False Positives) Recall: of all that actually have positive predicitions what fraction actually were positive? Recall = True Positives / (True Positives + False Negatives) Cross Entropy Used to calculate how far off your label prediction is. Some times denoted by CE. Cross entropy is a loss function is related to the entropy of thermodynamics concept of entropy. This is used in multi class classification to find the error in the predicition. Learning Rate [2] The learning rate is the magnitude at which you’re adjusting your weights of the network during optimization after back propagation. The learning rate is a hyper parameter that will be different for a variety of problems. This should be cross validated on. # ---- Vanilla Gradient Descent ----# W is your matrix of weights# dW is the gradient of W # Adjust the weights of our layer by multiplying our gradient times our learning_rate (Which is a scalar value) W -= learning_rate * dW This is a living document, if anything you think should be added let me know and I will add and credit you. [1] * Suggested by: InflationAaron [2] * Suggested by: Juan De Dios Santos [3] * Suggested by: Brandon Fryslie To take a look at different types of models and sample code check out . TensorFlow in a Nutshell — Part Three: All the Models As always check out my other articles at camron.xyz

Deep Learning Cheat Sheet

The fast and easy guide to the most popular Deep Learning framework in the world. Make sure to check out the other articles . here Overview In this installment we will be going over all the abstracted models that are currently available in TensorFlow and describe use cases for that particular model as well as simple sample code. Full sources of working examples are in the . TensorFlow In a Nutshell repo A recurrent neural network Recurrent Neural Networks Language Modeling, Machine translation, Word embedding, Text processing. Use Cases: Since the advent of Long Short Term Memory and Gated Recurrent Units, Recurrent Neural Networks have made leaps and bounds above other models in natural language processing. They can be fed vectors representing characters and be trained to generate new sentences based on the training set. The merit in this model is that it keeps the context of the sentence and derives meaning that “cat sat on the mat” means the cat is on the mat. Since the creation of TensorFlow writing these networks have become increasingly simpler. There are even hidden features covered by Denny Britz that make writing RNN’s even simpler heres a quick example. here import tensorflow as tfimport numpy as np X = np.random.randn(2, 10, 8) # Create input data X[1,6,:] = 0X_lengths = [10, 6] # The second example is of length 6 cell = tf.nn.rnn_cell.LSTMCell(num_units=64, state_is_tuple= )cell = tf.nn.rnn_cell.DropoutWrapper(cell=cell, output_keep_prob=0.5)cell = tf.nn.rnn_cell.MultiRNNCell(cells=[cell] * 4, state_is_tuple= ) True True outputs, last_states = tf.nn.dynamic_rnn(cell=cell,dtype=tf.float64,sequence_length=X_lengths,inputs=X) result = tf.contrib.learn.run_n({"outputs": outputs, "last_states": last_states},n=1,feed_dict= ) None Convolution Neural Network Convolution Neural Networks Image processing, Facial recognition, Computer Vision Use Cases: Convolution Neural Networks are unique because they’re created in mind that the input will be an image. CNNs perform a sliding window function to a matrix. The window is called a kernel and it slides across the image creating a convolved feature. from http://deeplearning.standford.edu/wiki/index.php/Feature_extraction_using_convolution Creating a convolved feature allows for edge detection which then allows for a to depict objects from pictures. network edge detection from GIMP manual The convolved feature to create this looks like this matrix below: Convolved feature from GIMP manual Here’s a sample of code to identify handwritten digits from the MNIST dataset. ### Convolutional networkdef max_pool_2x2(tensor_in):return tf.nn.max_pool(tensor_in, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') def conv_model(X, y): reshape X to 4d tensor with 2nd and 3rd dimensions being image width and height final dimension being the number of color channels. X = tf.reshape(X, [-1, 28, 28, 1]) first conv layer will compute 32 features for each 5x5 patch with tf.variable_scope('conv_layer1'):h_conv1 = learn.ops.conv2d(X, n_filters=32, filter_shape=[5, 5],bias=True, activation=tf.nn.relu)h_pool1 = max_pool_2x2(h_conv1) second conv layer will compute 64 features for each 5x5 patch. with tf.variable_scope('conv_layer2'):h_conv2 = learn.ops.conv2d(h_pool1, n_filters=64, filter_shape=[5, 5],bias=True, activation=tf.nn.relu)h_pool2 = max_pool_2x2(h_conv2) # reshape tensor into a batch of vectors  
h\_pool2\_flat = tf.reshape(h\_pool2, \[-1, 7 \* 7 \* 64\]) densely connected layer with 1024 neurons. h_fc1 = learn.ops.dnn(h_pool2_flat, [1024], activation=tf.nn.relu, dropout=0.5)return learn.models.logistic_regression(h_fc1, y) Feed Forward Neural Networks Classification and Regression Use Cases: These networks consist of perceptrons in layers that take inputs that pass information on to the next layer. The last layer in the network produces the output. There is no connection between each node in a given layer. The layer that has no original input and no final output is called the hidden layer. The goal of this network is similar to other supervised neural networks using back propagation, to make inputs have the desired trained outputs. These are some of the simplest effective neural networks for classification and regression problems. We will show how easy it is to create a feed forward network to classify handwritten digits: def init_weights(shape):return tf.Variable(tf.random_normal(shape, stddev=0.01)) def model(X, w_h, w_o):h = tf.nn.sigmoid(tf.matmul(X, w_h)) # this is a basic mlp, think 2 stacked logistic regressionsreturn tf.matmul(h, w_o) # note that we dont take the softmax at the end because our cost fn does that for us mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels X = tf.placeholder("float", [None, 784])Y = tf.placeholder("float", [None, 10]) w_h = init_weights([784, 625]) # create symbolic variablesw_o = init_weights([625, 10]) py_x = model(X, w_h, w_o) cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(py_x, Y)) # compute coststrain_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost) # construct an optimizerpredict_op = tf.argmax(py_x, 1) # Launch the graph in a sessionwith tf.Session() as sess:# you need to initialize all variablestf.initialize_all_variables().run() for i in range(100):for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+1, 128)):sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end]})print(i, np.mean(np.argmax(teY, axis=1) ==sess.run(predict_op, feed_dict={X: teX, Y: teY}))) Linear Models Classification and Regression Use Cases: Linear models take X values and produce a line of best fit used for classification and regression of Y values. For example if you have a list of house sizes and their price in a neighborhood you can predict the price of house given the size using a linear model. One thing to note is that linear models can be used for multiple X features. For example in the housing example we can create a linear model given house sizes, how many rooms, how many bathrooms and price and predict price given a house with size, # of rooms, # of bathrooms. import numpy as npimport tensorflow as tf def weight_variable(shape):initial = tf.truncated_normal(shape, stddev=1)return tf.Variable(initial) # datasetxx = np.random.randint(0,1000,[1000,3])/1000.yy = xx[:,0] * 2 + xx[:,1] * 1.4 + xx[:,2] * 3 # modelx = tf.placeholder(tf.float32, shape=[None, 3])y_ = tf.placeholder(tf.float32, shape=[None])W1 = weight_variable([3, 1])y = tf.matmul(x, W1) # training and cost functioncost_function = tf.reduce_mean(tf.square(tf.squeeze(y) - y_))train_function = tf.train.AdamOptimizer(1e-2).minimize(cost_function) # create a sessionsess = tf.Session() # trainsess.run(tf.initialize_all_variables())for i in range(10000):sess.run(train_function, feed_dict={x:xx, y_:yy})if i % 1000 == 0:print(sess.run(cost_function, feed_dict={x:xx, y_:yy})) Support Vector Machines Currently only Binary Classification Use Cases: The general idea behind a SVM is that there is an optimal hyperplane for linearly separable patterns. For data that is not linearly separable we can use a kernel function to transform the original data into a new space. SVMs maximize the margin around separating the hyperplane. They work extremely well in high dimensional spaces and and are still effective if the dimensions are greater than the number of samples. def input_fn():return {'example_id': tf.constant(['1', '2', '3']),'price': tf.constant([[0.6], [0.8], [0.3]]),'sq_footage': tf.constant([[900.0], [700.0], [600.0]]),'country': tf.SparseTensor(values=['IT', 'US', 'GB'],indices=[[0, 0], [1, 3], [2, 1]],shape=[3, 5]),'weights': tf.constant([[3.0], [1.0], [1.0]])}, tf.constant([[1], [0], [1]]) price = tf.contrib.layers.real_valued_column('price')sq_footage_bucket = tf.contrib.layers.bucketized_column(tf.contrib.layers.real_valued_column('sq_footage'),boundaries=[650.0, 800.0])country = tf.contrib.layers.sparse_column_with_hash_bucket('country', hash_bucket_size=5)sq_footage_country = tf.contrib.layers.crossed_column([sq_footage_bucket, country], hash_bucket_size=10)svm_classifier = tf.contrib.learn.SVM(feature_columns=[price, sq_footage_bucket, country, sq_footage_country],example_id_column='example_id',weight_column_name='weights',l1_regularization=0.1,l2_regularization=1.0) svm_classifier.fit(input_fn=input_fn, steps=30)accuracy = svm_classifier.evaluate(input_fn=input_fn, steps=1)['accuracy'] Deep and Wide Models Recommendation systems, Classification and Regression Use Cases: Deep and Wide models were covered with greater detail in , so we won’t get too heavy here. A Wide and Deep Network combines a linear model with a feed forward neural net so that our predictions will have memorization and generalization. This type of model can be used for classification and regression problems. This allows for less feature engineering with relatively accurate predictions. Thus, getting the best of both worlds. Here’s a code snippet from . part two part two’s github def input_fn(df, train=False):"""Input builder function.""" Creates a dictionary mapping from each continuous feature column name (k) to the values of that column stored in a constant Tensor. continuous_cols = {k: tf.constant(df[k].values) for k in CONTINUOUS_COLUMNS} Creates a dictionary mapping from each categorical feature column name (k) to the values of that column stored in a tf.SparseTensor. categorical_cols = {k: tf.SparseTensor(indices=[[i, 0] for i in range(df[k].size)],values=df[k].values,shape=[df[k].size, 1])for k in CATEGORICAL_COLUMNS} Merges the two dictionaries into one. feature_cols = dict(continuous_cols)feature_cols.update(categorical_cols) Converts the label column into a constant Tensor. if train:label = tf.constant(df[SURVIVED_COLUMN].values)# Returns the feature columns and the label.return feature_cols, labelelse:return feature_cols m = build_estimator(model_dir)m.fit(input_fn=lambda: input_fn(df_train, True), steps=200)print m.predict(input_fn=lambda: input_fn(df_test))results = m.evaluate(input_fn=lambda: input_fn(df_train, True), steps=1)for key in sorted(results):print("%s: %s" % (key, results[key])) Random Forest Classification and Regression Use Cases: Random Forest model takes many different classification trees and each tree votes for that class. The forest chooses the classification having the most votes. Random Forests do not overfit, you can run as many treees as you want and it is relatively fast. Give it a try on the iris data with this snippet below: hparams = tf.contrib.tensor_forest.python.tensor_forest.ForestHParams(num_trees=3, max_nodes=1000, num_classes=3, num_features=4)classifier = tf.contrib.learn.TensorForestEstimator(hparams) iris = tf.contrib.learn.datasets.load_iris()data = iris.data.astype(np.float32)target = iris.target.astype(np.float32) monitors = [tf.contrib.learn.TensorForestLossMonitor(10, 10)]classifier.fit(x=data, y=target, steps=100, monitors=monitors)classifier.evaluate(x=data, y=target, steps=10) Bayesian Reinforcement Learning Classification and Regression Use Cases: In the contrib folder of TensorFlow there is a library called BayesFlow. BayesFlow has no documentation except for an example of the REINFORCE algorithm. This algorithm is proposed in a by Ronald Williams. paper ward ncrement = onnegative actor * ffset einforcement * haracteristic ligibility RE I N F O R C E This network trying to solve an immediate reinforcement task, adjusts the weights after getting the reinforcement value at each trial. At the end of each trial each weight is incremented by a learning rate factor multiplied by the reinforcement value minus the baseline multiplied by characteristic eligibility. Williams paper also discusses the use of back propagation to train the REINFORCE network. learning """Build the Split-Apply-Merge Model.Route each value of input [-1, -1, 1, 1] through one of thefunctions, plus_1, minus_1.  The decision for routing is made by4 Bernoulli R.V.s whose parameters are determined by a neural networkapplied to the input.  REINFORCE is used to update the NN parameters.Returns:The 3-tuple (route_selection, routing_loss, final_loss), where:- route_selection is an int 4-vector- routing_loss is a float 4-vector- final_loss is a float scalar."""inputs = tf.constant([[-1.0], [-1.0], [1.0], [1.0]])targets = tf.constant([[0.0], [0.0], [0.0], [0.0]])paths = [plus_1, minus_1]weights = tf.get_variable("w", [1, 2])bias = tf.get_variable("b", [1, 1])logits = tf.matmul(inputs, weights) + bias # REINFORCE forward steproute_selection = st.StochasticTensor(distributions.Categorical, logits=logits) Linear Chain Conditional Random Fields Sequential Data Use Cases: CRFs are conditional probability distributions that factoirze according to an undirected model. They predict a label for a single sample keeping context from the neighboring samples. CRFs are similar to Hidden Markov Models. CRFs are often used for image segmentation and object recognition, as well as shallow parsing, named entity recognition and gene finding. # Train for a fixed number of iterations.session.run(tf.initialize_all_variables())for i in range(1000):tf_unary_scores, tf_transition_params, _ = session.run([unary_scores, transition_params, train_op])if i % 100 == 0:correct_labels = 0total_labels = 0for tf_unary_scores_, y_, sequence_length_ in zip(tf_unary_scores, y, sequence_lengths):# Remove padding from the scores and tag sequence.tf_unary_scores_ = tf_unary_scores_[:sequence_length_]y_ = y_[:sequence_length_] # Compute the highest scoring sequence.  
    viterbi\_sequence, \_ = tf.contrib.crf.viterbi\_decode(  
        tf\_unary\_scores\_, tf\_transition\_params)  

    # Evaluate word-level accuracy.  
    correct\_labels += np.sum(np.equal(viterbi\_sequence, y\_))  
    total\_labels += sequence\_length\_  
  accuracy = 100.0 \* correct\_labels / float(total\_labels)  
  print("Accuracy: %.2f%%" % accuracy) Conclusion Ever since TensorFlow has been released the community surrounding the project has been adding more packages, examples and cases for using this amazing library. Even at the time of writing this article there are more models and sample code being written. It is amazing to see how much TensorFlow as grown in these past few months. The ease of use and diversity in the package are increasing overtime and don’t seem to be slowing down anytime soon. As always — Feel free to email me any questions or inquiries at camron@camron.xyz Originally posted at Camron.xyz

TensorFlow in a Nutshell — Part Three: All the Models

Vectors and vector search are key components of large language models (LLMs), but they are useful in a host of other applications across many use cases that you might not have considered. How about the most efficient way to deliver retail goods? In two prior articles in this series, I told a story of a hypothetical contractor who was hired to help implement AI/ML solutions at a big-box retailer and then explored how this distributed systems and AI specialist used vector search to drive results with customer promotions at the company. Now, I’ll walk you through how this contractor uses vector search to optimize trucking routes. The problem While we were looking at our options for scaling-down (and ultimately disabling) the recommendation batch job from the first story in this series, we were invited to a meeting with the Transportation Services team. They had heard how we assisted the Promotions team and were wondering if we could take a look at a problem of theirs. BigBoxCo has its products trucked in from airports and shipping ports. Once at the distribution center (DC), they are tagged and separated into smaller shipments for the individual brick-and-mortar stores. While we have our own semi trailers for this part of the product journey, the fleet isn’t efficiently organized. Currently, the drivers are given a list of stores on the truck’s digital device, and the supervisor suggests a route. However, the drivers often balk about the order of store stops, and they often disregard their supervisors’ route suggestions. This, of course, leads to variances in expected shipment and restock times, as well as in total time taken. Knowing this, the DC staff is unable to fill each truck container completely, because they have to leave space in the truck for access to the product pallets for each store. Ideally, the product pallets would be ordered with the first store's pallet in the most accessible position in the trailer. Improving the experience The Transportation Services team would like us to examine the available data and see if there is a smarter way to approach this problem. For instance, what if there was a way that we could pre-determine the best possible route to take by determining the order in which the driver should visit the stores? This is similar to the “traveling salesman problem” (TSP), a hypothetical problem in which a salesman is given a list of cities to visit, and needs to figure out the most efficient route between them. While coded implementations of the TSP can become quite complex, we might be able to use a vector database like Apache Cassandra’s for vector search capability to solve this. The obvious approach is to plot out each of the geolocation coordinates of each destination city.  However, the cities are only spread out over a local, metropolitan area, which means that latitude and longitude whole numbers would be mostly the same. That isn’t going to lead to a lot of easily detectable variance, so we should refocus that data by just considering the numbers to the right of the Geo URI scheme decimal point. For example, the city of Rogersville (the location of one of our BigBoxCo stores) has a Geo URI of 45.200,-93.567. We’ll be able to detect variance from this and other vectors more easily if we look to the right of each decimal point of our coordinates, arriving at adjusted coordinates of 200,-567 (instead of 45.200,-93.567). Taking this approach with the local metro cities with our stores gives us the following data: Implementation Now that we have data, we can create a table in our Cassandra cluster with a two-dimensional vector. We will also need to create a SSTable attached secondary index (SASI) on the vector column: CREATE TABLE bigbox.location_vectors (
  location_id text PRIMARY KEY,
  location_name text,
  location_vector vector<float, 2>);
CREATE CUSTOM INDEX ON bigbox.location_vectors (location_vector) 
USING 'StorageAttachedIndex'; This will enable us to use a vector search to determine the order in which to visit each city. It’s important to note, however, that vector searches are based on cosine-based calculations for distance, assuming that the points are on a flat plane. As we know, the Earth is not a flat plane.  Calculating distances over a large geographic area should be done using another approach like the , which takes the characteristics of a sphere into account. But for our purposes in a small, local metro area, computing an approximate nearest neighbor (ANN) should work just fine. Haversine formula Now let us load our city vectors into the table, and we should be able to query it: INSERT INTO bigbox.location_vectors (location_id, location_name,
location_vector) VALUES ('B1643','Farley',[86, -263]);
INSERT INTO bigbox.location_vectors (location_id, location_name,
location_vector) VALUES (B9787,'Zarconia',[37, -359]);
INSERT INTO bigbox.location_vectors (location_id, location_name,
location_vector) VALUES (B2346,'Parktown',[-52, -348]);
INSERT INTO bigbox.location_vectors (location_id, location_name,
location_vector) VALUES ('B1643','Victoriaville',[94, -356]);
INSERT INTO bigbox.location_vectors (location_id, location_name,
location_vector) VALUES ('B6789','Rockton',[11, -456]);
INSERT INTO bigbox.location_vectors (location_id, location_name,
location_vector) VALUES ('B2345','Maplewood',[73, -456]);
INSERT INTO bigbox.location_vectors (location_id, location_name,
location_vector) VALUES ('B5243','Rogersville',[200, -567]); To begin a route, we will first consider the warehouse distribution center in Farley, which we have stored with a vector of 86, -263.  We can begin by querying the ` ` table for the ANNs of Farley’s vector: location_vectors SELECT location_id, location_name, location_vector,
similarity_cosine(location_vector,[86, -263]) AS similarity
FROM location_vectors
ORDER BY location_vector
ANN OF [86, -263] LIMIT 7; The results of the query look like this: location_id | location_name | location_vector | similarity 
-------------+---------------+-----------------+------------
       B1643 |        Farley |      [86, -263] |          1 
       B5243 |   Rogersville |     [200, -567] |   0.999867
       B1566 | Victoriaville |      [94, -356] |   0.999163 
       B2345 |     Maplewood |      [73, -456] |   0.993827 
       B9787 |      Zarconia |      [37, -359] |   0.988665
       B6789 |       Rockton |      [11, -456] |   0.978847
       B2346 |      Parktown |     [-52, -348] |   0.947053

(7 rows) Note that we have also included the results of the ` ’ function, so that the similarity of the ANN results is visible to us. As we can see, after disregarding Farley at the top (100% match for our starting point), the city of Rogersville is coming back as the approximate nearest neighbor. similarity_cosine Next, let’s build a microservice endpoint that essentially traverses the cities based on a starting point and the top ANN returned. It will also need to disregard cities that it’s already been to.  Therefore, we build a method that we can POST to, so that we can provide the ID of the starting city, as well as the list of cities for the proposed route in the body of the request: curl -s -XPOST http://127.0.0.1:8080/transportsvc/citylist/B1643 \
-d'["Rockton","Parktown","Rogersville","Victoriaville","Maplewood","Za
rconia"]' -H 'Content-Type: application/json' Calling this service with the ` ’ “B1643” (Farley) returns the following output: location_id ["Rogersville","Victoriaville","Maplewood","Zarconia","Rockton","Parktown"] So this works great in the sense that it’s providing some systematic guidance for our trucking routes. However, our service endpoint and (by proxy) our ANN query don’t have an understanding of the highway system that connects each of these cities. For now, it’s simply assuming that our trucks can travel to each city directly “as the crow flies.” Realistically, we know this isn’t the case. In fact, let’s look at a map of our metro area, with each of these cities and connecting highways marked (Figure 1). One way to increase accuracy here would be to create vectors for the segments of the highways. We could create a highway table and generate vectors for each by their starting and ending coordinates based on how they intersect with each other and our cities. CREATE TABLE highway_vectors (
 highway_name TEXT PRIMARY KEY,
 highway_vector vector<float,4>);

CREATE CUSTOM INDEX ON highway_vectors(highway_vector) USING 
'StorageAttachedIndex'; We can then insert vectors for each highway. We will also create entries for both directions of the highway segments so that our ANN query can use either city as the starting or ending points. For example: INSERT INTO highway_vectors(highway_name,highway_vector) 
VALUES('610-E2',[94,-356,86,-263]);
INSERT INTO highway_vectors(highway_name,highway_vector) 
VALUES('610-W2',[86,-263,94,-356]); Going off of the result from our original query, we can run another query to pull back highway vectors with an ANN of the coordinates for the DC in Farley (86,-263) and our store in Rogersville (200,-567): SELECT * FROM highway_vectors
ORDER BY highway_vector
ANN OF [86,-263,200,-567]
LIMIT 4;

 highway_name | highway_vector
--------------+-----------------------
       610-W2 |  [86, -263, 94, -356]
         54NW | [73, -456, 200, -567]
        610-W |  [94, -356, 73, -456]
        81-NW |  [37, -359, 94, -356]

(4 rows) Looking at the map shown in Figure 1, we can see that Farley and Rogersville are connected by highways 610 and 54. Now we’re on to something! We could build another service endpoint to build a highway route from one city to another based on the coordinates of the starting and ending cities. To make this service complete, we would want it to eliminate any “orphan” highways returned (highways that aren’t on our expected route) and include any cities with stores that we may want to stop at on the way. If we used the ` of Farley (B1643) and Rogersville (B5243), we should get an output that looks like this: location_ids ’ curl -s -XGET
http://127.0.0.1:8080/transportsvc/highways/from/B1643/to/B5243 \
-H 'Content-Type: application/json'
{"highways":[
    {"highway_name":"610-W2",
        "Highway_vector":{"values":[86.0,-263.0,94.0,-356.0]}},
    {"highway_name":"54NW",
        "highway_vector":{"values":[73.0,-456.0,200.0,-567.0]}},
    {"highway_name":"610-W",
        "highway_vector":{"values":[94.0,-356.0,73.0,-456.0]}}],
 "citiesOnRoute":["Maplewood","Victoriaville"]} Conclusions and next steps These new transportation services should significantly help our drivers and DC management. They should now be getting mathematically significant results for route determination between stores. A nice side benefit is that DC staff can fill the truck more efficiently.  With access to the route ahead of time, they can load pallets into the truck in a first-in-last-out (LIFO) approach, using more of the available space. While this is a good first step, we could make some future improvements once this initiative is deemed successful. A subscription to a traffic service will help in route planning and augmentation. This would allow a route recalculation based on significant local traffic events on one or more highways. We could also use the n-vector approach for coordinate positioning instead of using the abbreviated latitude and longitudinal coordinates. The advantage here is that our coordinates would already be converted to vectors, likely leading to more accurate nearest-neighbor approximations. Check out this GitHub repository for code for the above-described , and learn more about how . example transportation service endpoints DataStax enables generative AI with vector search By Aaron Ploetz, DataStax

Vector Search Applications: Optimizing Retail Trucking Routes

Aplicaciones de búsqueda de vectores: optimización de rutas de transporte minorista

Applications de recherche de vecteurs : optimisation des itinéraires de camionnage pour le commerce de détail

वेक्टर खोज अनुप्रयोग: खुदरा ट्रकिंग मार्गों का अनुकूलन

ベクトル検索アプリケーション: 小売トラック輸送ルートの最適化

Aplicações de pesquisa vetorial: otimizando rotas de transporte rodoviário de varejo

Ứng dụng tìm kiếm Vector: Tối ưu hóa các tuyến đường vận tải đường bộ bán lẻ

矢量搜索应用：优化零售货运路线

Stories, News & Mentions about CAMIONIX

Trending Topics

Classic

Neon Noir

Minty

Newspaper

HN StartUps